feat: add load scene tool

Author: Snowblaze

Editor/Tools/LoadSceneTool.cs

@@ -0,0 +1,115 @@
+using System;
+using UnityEngine;
+using UnityEditor;
+using Newtonsoft.Json.Linq;
+using McpUnity.Unity;
+using McpUnity.Utils;
+
+namespace McpUnity.Tools
+{
+    /// <summary>
+    /// Tool for loading a Unity scene, optionally additively
+    /// </summary>
+    public class LoadSceneTool : McpToolBase
+    {
+        public LoadSceneTool()
+        {
+            Name = "load_scene";
+            Description = "Loads a scene by path or name. Supports additive loading (default: false)";
+        }
+
+        /// <summary>
+        /// Execute the LoadScene tool with the provided parameters
+        /// </summary>
+        /// <param name="parameters">Tool parameters as a JObject</param>
+        public override JObject Execute(JObject parameters)
+        {
+            string scenePath = parameters["scenePath"]?.ToObject<string>();
+            string sceneName = parameters["sceneName"]?.ToObject<string>();
+            string folderPath = parameters["folderPath"]?.ToObject<string>();
+            bool additive = parameters["additive"]?.ToObject<bool?>() ?? false;
+
+            if (string.IsNullOrEmpty(scenePath))
+            {
+                if (string.IsNullOrEmpty(sceneName))
+                {
+                    return McpUnitySocketHandler.CreateErrorResponse(
+                        "Provide either 'scenePath' or 'sceneName'",
+                        "validation_error"
+                    );
+                }
+
+                // Resolve scene path by name (optionally within folderPath)
+                string filter = $"{sceneName} t:Scene";
+                string[] searchInFolders = null;
+                if (!string.IsNullOrEmpty(folderPath))
+                {
+                    if (!AssetDatabase.IsValidFolder(folderPath))
+                    {
+                        return McpUnitySocketHandler.CreateErrorResponse(
+                            $"Folder '{folderPath}' does not exist",
+                            "not_found_error"
+                        );
+                    }
+                    searchInFolders = new[] { folderPath };
+                }
+
+                var guids = AssetDatabase.FindAssets(filter, searchInFolders);
+                foreach (var guid in guids)
+                {
+                    var path = AssetDatabase.GUIDToAssetPath(guid);
+                    if (System.IO.Path.GetFileNameWithoutExtension(path) == sceneName)
+                    {
+                        scenePath = path;
+                        break;
+                    }
+                }
+
+                if (string.IsNullOrEmpty(scenePath))
+                {
+                    return McpUnitySocketHandler.CreateErrorResponse(
+                        $"Scene named '{sceneName}' not found",
+                        "not_found_error"
+                    );
+                }
+            }
+
+            try
+            {
+                // Avoid any save prompts: save open scenes before replacing them (non-additive)
+                if (!additive)
+                {
+                    UnityEditor.SceneManagement.EditorSceneManager.SaveOpenScenes();
+                }
+
+                var mode = additive
+                    ? UnityEditor.SceneManagement.OpenSceneMode.Additive
+                    : UnityEditor.SceneManagement.OpenSceneMode.Single;
+
+                var openedScene = UnityEditor.SceneManagement.EditorSceneManager.OpenScene(scenePath, mode);
+
+                // For non-additive, scene becomes active automatically. For additive, we do not change active scene.
+
+                McpLogger.LogInfo($"Loaded scene at path '{scenePath}' (additive={additive})");
+
+                return new JObject
+                {
+                    ["success"] = true,
+                    ["type"] = "text",
+                    ["message"] = $"Successfully loaded scene at path '{scenePath}' (additive={additive.ToString().ToLower()})",
+                    ["scenePath"] = scenePath,
+                    ["additive"] = additive
+                };
+            }
+            catch (Exception ex)
+            {
+                return McpUnitySocketHandler.CreateErrorResponse(
+                    $"Error loading scene: {ex.Message}",
+                    "scene_load_error"
+                );
+            }
+        }
+    }
+}
+
+

Editor/Tools/LoadSceneTool.cs.meta

@@ -261,6 +261,10 @@ private void RegisterTools()
             // Register DeleteSceneTool
             DeleteSceneTool deleteSceneTool = new DeleteSceneTool();
             _tools.Add(deleteSceneTool.Name, deleteSceneTool);
+
+            // Register LoadSceneTool
+            LoadSceneTool loadSceneTool = new LoadSceneTool();
+            _tools.Add(loadSceneTool.Name, loadSceneTool);
         }
 
         /// <summary>

Editor/UnityBridge/McpUnityServer.cs

@@ -15,6 +15,7 @@ import { registerAddAssetToSceneTool } from './tools/addAssetToSceneTool.js';
 import { registerUpdateGameObjectTool } from './tools/updateGameObjectTool.js';
 import { registerCreatePrefabTool } from './tools/createPrefabTool.js';
 import { registerDeleteSceneTool } from './tools/deleteSceneTool.js';
+import { registerLoadSceneTool } from './tools/loadSceneTool.js';
 import { registerGetMenuItemsResource } from './resources/getMenuItemResource.js';
 import { registerGetConsoleLogsResource } from './resources/getConsoleLogsResource.js';
 import { registerGetHierarchyResource } from './resources/getScenesHierarchyResource.js';
@@ -61,6 +62,7 @@ registerUpdateGameObjectTool(server, mcpUnity, toolLogger);
 registerCreatePrefabTool(server, mcpUnity, toolLogger);
 registerCreateSceneTool(server, mcpUnity, toolLogger);
 registerDeleteSceneTool(server, mcpUnity, toolLogger);
+registerLoadSceneTool(server, mcpUnity, toolLogger);
 
 // Register all resources into the MCP server
 registerGetTestsResource(server, mcpUnity, resourceLogger);

Server~/src/index.ts

@@ -0,0 +1,70 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { McpUnity } from '../unity/mcpUnity.js';
+import { McpUnityError, ErrorType } from '../utils/errors.js';
+import * as z from 'zod';
+import { Logger } from '../utils/logger.js';
+
+const toolName = 'load_scene';
+const toolDescription = 'Loads a scene by path or name. Supports additive loading (default: false)';
+
+const paramsSchema = z.object({
+  scenePath: z.string().optional().describe("Full asset path to the scene (e.g., 'Assets/Scenes/MyScene.unity')"),
+  sceneName: z.string().optional().describe('Scene name without extension (used if scenePath not provided)'),
+  folderPath: z.string().optional().describe("Optional folder scope to resolve sceneName under 'Assets'"),
+  additive: z.boolean().optional().describe('Load additively if true; default false')
+});
+
+export function registerLoadSceneTool(server: McpServer, mcpUnity: McpUnity, logger: Logger) {
+  logger.info(`Registering tool: ${toolName}`);
+
+  server.tool(
+    toolName,
+    toolDescription,
+    paramsSchema.shape,
+    async (params: any) => {
+      try {
+        logger.info(`Executing tool: ${toolName}`, params);
+        const result = await toolHandler(mcpUnity, params);
+        logger.info(`Tool execution successful: ${toolName}`);
+        return result;
+      } catch (error) {
+        logger.error(`Tool execution failed: ${toolName}`, error);
+        throw error;
+      }
+    }
+  );
+}
+
+async function toolHandler(mcpUnity: McpUnity, params: any) {
+  if (!params.scenePath && !params.sceneName) {
+    throw new McpUnityError(
+      ErrorType.VALIDATION,
+      "Either 'scenePath' or 'sceneName' must be provided"
+    );
+  }
+
+  const response = await mcpUnity.sendRequest({
+    method: toolName,
+    params
+  });
+
+  if (!response.success) {
+    throw new McpUnityError(
+      ErrorType.TOOL_EXECUTION,
+      response.message || 'Failed to load scene'
+    );
+  }
+
+  return {
+    content: [{
+      type: response.type,
+      text: response.message || 'Successfully loaded scene'
+    }],
+    data: {
+      scenePath: response.scenePath,
+      additive: response.additive
+    }
+  };
+}
+
+