update

Author: Scriptwonder

MCPForUnity/Editor/Tools/FindGameObjects.cs

@@ -33,6 +33,51 @@ public static object HandleCommand(JObject @params)
             // Parse search parameters
             string searchMethod = p.Get("searchMethod", "by_name");
 
+            // Search options (supports multiple parameter name variants)
+            bool includeInactive = p.GetBool("includeInactive", false) ||
+                                   p.GetBool("searchInactive", false);
+
+            // Pagination parameters using standard PaginationRequest
+            var pagination = PaginationRequest.FromParams(@params, defaultPageSize: 50);
+            pagination.PageSize = Mathf.Clamp(pagination.PageSize, 1, 500);
+
+            // Check for multi-term search (searchTerms array)
+            JToken searchTermsToken = @params["searchTerms"];
+            if (searchTermsToken != null && searchTermsToken.Type == JTokenType.Array)
+            {
+                try
+                {
+                    var searchTerms = searchTermsToken.ToObject<string[]>();
+                    var resultsByTerm = new Dictionary<string, object>();
+
+                    foreach (string term in searchTerms)
+                    {
+                        if (string.IsNullOrEmpty(term)) continue;
+                        var ids = GameObjectLookup.SearchGameObjects(searchMethod, term, includeInactive, 0);
+                        var paged = PaginationResponse<int>.Create(ids, pagination);
+                        resultsByTerm[term] = new
+                        {
+                            instanceIDs = paged.Items,
+                            totalCount = paged.TotalCount,
+                            hasMore = paged.HasMore,
+                        };
+                    }
+
+                    return new SuccessResponse("Found GameObjects (multi-term)", new
+                    {
+                        results = resultsByTerm,
+                        searchMethod = searchMethod,
+                        pageSize = pagination.PageSize,
+                    });
+                }
+                catch (System.Exception ex)
+                {
+                    McpLog.Error($"[FindGameObjects] Error in multi-term search: {ex.Message}");
+                    return new ErrorResponse($"Error searching GameObjects: {ex.Message}");
+                }
+            }
+
+            // Single-term search (original behavior)
             // Try searchTerm, search_term, or target (for backwards compatibility)
             string searchTerm = p.Get("searchTerm");
             if (string.IsNullOrEmpty(searchTerm))
@@ -45,19 +90,11 @@ public static object HandleCommand(JObject @params)
                 return new ErrorResponse("'searchTerm' or 'target' parameter is required.");
             }
 
-            // Pagination parameters using standard PaginationRequest
-            var pagination = PaginationRequest.FromParams(@params, defaultPageSize: 50);
-            pagination.PageSize = Mathf.Clamp(pagination.PageSize, 1, 500);
-
-            // Search options (supports multiple parameter name variants)
-            bool includeInactive = p.GetBool("includeInactive", false) ||
-                                   p.GetBool("searchInactive", false);
-
             try
             {
                 // Get all matching instance IDs
                 var allIds = GameObjectLookup.SearchGameObjects(searchMethod, searchTerm, includeInactive, 0);
-                
+
                 // Use standard pagination response
                 var paginatedResult = PaginationResponse<int>.Create(allIds, pagination);
 

MCPForUnity/Editor/Tools/ManageAsset.cs

@@ -683,9 +683,9 @@ out DateTime parsedDate
                     string.Join(" ", searchFilters),
                     folderScope
                 );
-                List<object> results = new List<object>();
-                int totalFound = 0;
 
+                // First pass: collect matching asset paths (lightweight — no asset loading)
+                List<string> filteredPaths = new List<string>();
                 foreach (string guid in guids)
                 {
                     string assetPath = AssetDatabase.GUIDToAssetPath(guid);
@@ -699,18 +699,26 @@ out DateTime parsedDate
                             Path.Combine(Directory.GetCurrentDirectory(), assetPath)
                         );
                         if (lastWriteTime <= filterDateAfter.Value)
-                        {
-                            continue; // Skip assets older than or equal to the filter date
-                        }
+                            continue;
                     }
 
-                    totalFound++; // Count matching assets before pagination
-                    results.Add(GetAssetData(assetPath, generatePreview));
+                    filteredPaths.Add(assetPath);
                 }
 
-                // Apply pagination
+                int totalFound = filteredPaths.Count;
+
+                // Paginate BEFORE loading asset data to avoid O(n) asset loads
                 int startIndex = (pageNumber - 1) * pageSize;
-                var pagedResults = results.Skip(startIndex).Take(pageSize).ToList();
+                var pagedPaths = filteredPaths.Skip(startIndex).Take(pageSize).ToList();
+
+                // Only load full asset data for the current page
+                List<object> pagedResults = new List<object>(pagedPaths.Count);
+                foreach (string assetPath in pagedPaths)
+                {
+                    var data = GetAssetData(assetPath, generatePreview);
+                    if (data != null)
+                        pagedResults.Add(data);
+                }
 
                 return new SuccessResponse(
                     $"Found {totalFound} asset(s). Returning page {pageNumber} ({pagedResults.Count} assets).",
@@ -719,6 +727,7 @@ out DateTime parsedDate
                         totalAssets = totalFound,
                         pageSize = pageSize,
                         pageNumber = pageNumber,
+                        totalPages = (int)Math.Ceiling((double)totalFound / pageSize),
                         assets = pagedResults,
                     }
                 );

MCPForUnity/Editor/Tools/ManageScene.cs

@@ -218,6 +218,8 @@ public static object HandleCommand(JObject @params)
                     return ga;
                 case "get_build_settings":
                     return GetBuildSettingsScenes();
+                case "get_stats":
+                    return GetSceneStats();
                 case "screenshot":
                     return CaptureScreenshot(cmd);
                 case "scene_view_frame":
@@ -413,9 +415,17 @@ private static object SaveScene(string fullPath, string relativePath)
                 if (saved)
                 {
                     AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
+                    // Re-fetch scene to get accurate isDirty after save
+                    currentScene = EditorSceneManager.GetActiveScene();
                     return new SuccessResponse(
                         $"Scene '{currentScene.name}' saved successfully to '{finalPath}'.",
-                        new { path = finalPath, name = currentScene.name }
+                        new
+                        {
+                            path = finalPath,
+                            name = currentScene.name,
+                            isDirty = currentScene.isDirty,
+                            savedAt = DateTime.UtcNow.ToString("o"),
+                        }
                     );
                 }
                 else
@@ -1256,6 +1266,71 @@ private static object GetBuildSettingsScenes()
             }
         }
 
+        private static object GetSceneStats()
+        {
+            try
+            {
+                Scene activeScene = EditorSceneManager.GetActiveScene();
+                if (!activeScene.IsValid() || !activeScene.isLoaded)
+                    return new ErrorResponse("No valid and loaded scene is active.");
+
+                var roots = activeScene.GetRootGameObjects();
+                int totalObjects = 0;
+                int rendererCount = 0;
+                int lightCount = 0;
+                int cameraCount = 0;
+                int canvasCount = 0;
+                int scriptedObjectCount = 0;
+                int rigidbodyCount = 0;
+                int colliderCount = 0;
+                int audioSourceCount = 0;
+
+                void CountRecursive(GameObject go)
+                {
+                    totalObjects++;
+                    if (go.GetComponent<Renderer>()) rendererCount++;
+                    if (go.GetComponent<Light>()) lightCount++;
+                    if (go.GetComponent<Camera>()) cameraCount++;
+                    if (go.GetComponent<Canvas>()) canvasCount++;
+                    if (go.GetComponent<Rigidbody>() || go.GetComponent<Rigidbody2D>()) rigidbodyCount++;
+                    if (go.GetComponent<Collider>() || go.GetComponent<Collider2D>()) colliderCount++;
+                    if (go.GetComponent<AudioSource>()) audioSourceCount++;
+                    var scripts = go.GetComponents<MonoBehaviour>();
+                    if (scripts != null && scripts.Length > 0) scriptedObjectCount++;
+                    foreach (Transform child in go.transform)
+                    {
+                        if (child != null) CountRecursive(child.gameObject);
+                    }
+                }
+
+                foreach (var root in roots)
+                {
+                    if (root != null) CountRecursive(root);
+                }
+
+                return new SuccessResponse("Scene statistics retrieved.", new
+                {
+                    sceneName = activeScene.name,
+                    scenePath = activeScene.path,
+                    isDirty = activeScene.isDirty,
+                    rootCount = roots.Length,
+                    totalObjects,
+                    rendererCount,
+                    lightCount,
+                    cameraCount,
+                    canvasCount,
+                    scriptedObjectCount,
+                    rigidbodyCount,
+                    colliderCount,
+                    audioSourceCount,
+                });
+            }
+            catch (Exception e)
+            {
+                return new ErrorResponse($"Error getting scene stats: {e.Message}");
+            }
+        }
+
         private static object GetSceneHierarchyPaged(SceneCommand cmd)
         {
             try

Server/src/cli/commands/scene.py

@@ -93,6 +93,15 @@ def active():
     click.echo(format_output(result, config.format))
 
 
+@scene.command("stats")
+@handle_unity_errors
+def stats():
+    """Get scene statistics (object counts, component counts, etc.)."""
+    config = get_config()
+    result = run_command("manage_scene", {"action": "get_stats"}, config)
+    click.echo(format_output(result, config.format))
+
+
 @scene.command("load")
 @click.argument("scene")
 @click.option(

Server/src/models/models.py

@@ -10,7 +10,11 @@ class MCPResponse(BaseModel):
     data: Any | None = None
     # Optional hint for clients about how to handle the response.
     # Supported values:
-    #   - "retry": Unity is temporarily reloading; call should be retried politely.
+    #   - "retry": Unity is temporarily unavailable; call should be retried politely.
+    #   - "connection_lost": The connection to Unity was lost mid-request.
+    #     Distinct from a Unity-side error — the request may not have been received.
+    #   - "timeout": Unity did not respond within the expected time.
+    #     Check if Unity is compiling or unresponsive before retrying.
     hint: str | None = None
 
 

Server/src/services/tools/find_gameobjects.py

@@ -20,15 +20,23 @@
         "Returns instance IDs only (paginated). "
         "Then use mcpforunity://scene/gameobject/{id} resource for full data, "
         "or mcpforunity://scene/gameobject/{id}/components for component details. "
-        "For CRUD operations (create/modify/delete), use manage_gameobject instead."
+        "For CRUD operations (create/modify/delete), use manage_gameobject instead. "
+        "Supports multi-term search: pass search_terms (list) instead of search_term "
+        "to search for multiple objects in a single call. Returns results keyed by term."
     )
 )
 async def find_gameobjects(
     ctx: Context,
     search_term: Annotated[
-        str,
-        Field(description="The value to search for (name, tag, layer name, component type, or path)")
-    ],
+        str | None,
+        Field(description="The value to search for (name, tag, layer name, component type, or path). "
+              "Use search_terms instead for multi-term search.")
+    ] = None,
+    search_terms: Annotated[
+        list[str] | None,
+        Field(description="List of values to search for in a single call. "
+              "Returns results keyed by term. Mutually exclusive with search_term.")
+    ] = None,
     search_method: Annotated[
         Literal["by_name", "by_tag", "by_layer", "by_component", "by_path", "by_id"],
         Field(
@@ -72,10 +80,10 @@ async def find_gameobjects(
     unity_instance = await get_unity_instance_from_context(ctx)
 
     # Validate required parameters before preflight I/O
-    if not search_term:
+    if not search_term and not search_terms:
         return {
             "success": False,
-            "message": "Missing required parameter 'search_term'. Specify what to search for."
+            "message": "Missing required parameter: provide 'search_term' or 'search_terms'."
         }
 
     gate = await preflight(ctx, wait_for_no_compile=True, refresh_if_dirty=True)
@@ -88,13 +96,19 @@ async def find_gameobjects(
     cursor = coerce_int(cursor, default=0)
 
     try:
-        params = {
+        params: dict[str, Any] = {
             "searchMethod": search_method,
-            "searchTerm": search_term,
             "includeInactive": include_inactive,
             "pageSize": page_size,
             "cursor": cursor,
         }
+
+        # Multi-term search
+        if search_terms:
+            params["searchTerms"] = search_terms
+        else:
+            params["searchTerm"] = search_term
+
         params = {k: v for k, v in params.items() if v is not None}
 
         response = await send_with_unity_instance(

Server/src/services/tools/manage_scene.py

@@ -15,7 +15,8 @@
 @mcp_for_unity_tool(
     description=(
         "Performs CRUD operations on Unity scenes. "
-        "Read-only actions: get_hierarchy, get_active, get_build_settings, screenshot, scene_view_frame. "
+        "Read-only actions: get_hierarchy, get_active, get_build_settings, get_stats, screenshot, scene_view_frame. "
+        "get_stats returns lightweight scene statistics (rootCount, totalObjects, rendererCount, lightCount, cameraCount, etc.) — use for quick scene validation. "
         "Modifying actions: create, load, save. "
         "screenshot supports include_image=true to return an inline base64 PNG for AI vision. "
         "screenshot with batch='surround' captures 6 angles around the scene (no file saved) for comprehensive scene understanding. "
@@ -36,6 +37,7 @@ async def manage_scene(
         "get_hierarchy",
         "get_active",
         "get_build_settings",
+        "get_stats",
         "screenshot",
         "scene_view_frame",
     ], "Perform CRUD operations on Unity scenes, capture screenshots, and control the Scene View camera."],