Update

To comply with the current server setting

Author: Scriptwonder

MCPForUnity/Editor/Tools/BatchExecute.cs

@@ -0,0 +1,130 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using MCPForUnity.Editor.Helpers;
+using Newtonsoft.Json.Linq;
+
+namespace MCPForUnity.Editor.Tools
+{
+    /// <summary>
+    /// Executes multiple MCP commands within a single Unity-side handler. Commands are executed sequentially
+    /// on the main thread to preserve determinism and Unity API safety.
+    /// </summary>
+    [McpForUnityTool("batch_execute", AutoRegister = false)]
+    public static class BatchExecute
+    {
+        private const int MaxCommandsPerBatch = 25;
+
+        public static async Task<object> HandleCommand(JObject @params)
+        {
+            if (@params == null)
+            {
+                return new ErrorResponse("'commands' payload is required.");
+            }
+
+            var commandsToken = @params["commands"] as JArray;
+            if (commandsToken == null || commandsToken.Count == 0)
+            {
+                return new ErrorResponse("Provide at least one command entry in 'commands'.");
+            }
+
+            if (commandsToken.Count > MaxCommandsPerBatch)
+            {
+                return new ErrorResponse($"A maximum of {MaxCommandsPerBatch} commands are allowed per batch.");
+            }
+
+            bool failFast = @params.Value<bool?>("failFast") ?? false;
+            bool parallelRequested = @params.Value<bool?>("parallel") ?? false;
+            int? maxParallel = @params.Value<int?>("maxParallelism");
+
+            if (parallelRequested)
+            {
+                McpLog.Warn("batch_execute parallel mode requested, but commands will run sequentially on the main thread for safety.");
+            }
+
+            var commandResults = new List<object>(commandsToken.Count);
+            int successCount = 0;
+            int failureCount = 0;
+
+            foreach (var token in commandsToken)
+            {
+                if (token is not JObject commandObj)
+                {
+                    failureCount++;
+                    commandResults.Add(new
+                    {
+                        success = false,
+                        tool = (string)null,
+                        error = "Command entries must be JSON objects."
+                    });
+                    if (failFast)
+                    {
+                        break;
+                    }
+                    continue;
+                }
+
+                string toolName = commandObj["tool"]?.ToString();
+                var commandParams = commandObj["params"] as JObject ?? new JObject();
+
+                if (string.IsNullOrWhiteSpace(toolName))
+                {
+                    failureCount++;
+                    commandResults.Add(new
+                    {
+                        success = false,
+                        tool = toolName,
+                        error = "Each command must include a non-empty 'tool' field."
+                    });
+                    if (failFast)
+                    {
+                        break;
+                    }
+                    continue;
+                }
+
+                try
+                {
+                    var result = await CommandRegistry.InvokeCommandAsync(toolName, commandParams).ConfigureAwait(true);
+                    successCount++;
+                    commandResults.Add(new
+                    {
+                        success = true,
+                        tool = toolName,
+                        result
+                    });
+                }
+                catch (Exception ex)
+                {
+                    failureCount++;
+                    commandResults.Add(new
+                    {
+                        success = false,
+                        tool = toolName,
+                        error = ex.Message
+                    });
+
+                    if (failFast)
+                    {
+                        break;
+                    }
+                }
+            }
+
+            bool overallSuccess = failureCount == 0;
+            var data = new
+            {
+                results = commandResults,
+                successCount,
+                failureCount,
+                parallelRequested,
+                parallelApplied = false,
+                maxParallelism = maxParallel
+            };
+
+            return overallSuccess
+                ? new SuccessResponse("Batch execution completed.", data)
+                : new ErrorResponse("One or more commands failed.", data);
+        }
+    }
+}

MCPForUnity/Editor/Tools/CommandRegistry.cs

@@ -248,6 +248,36 @@ public static object ExecuteCommand(string commandName, JObject @params, TaskCom
             return handlerInfo.SyncHandler(@params);
         }
 
+        /// <summary>
+        /// Execute a command handler and return its raw result, regardless of sync or async implementation.
+        /// Used internally for features like batch execution where commands need to be composed.
+        /// </summary>
+        /// <param name="commandName">The registered command to execute.</param>
+        /// <param name="params">Parameters to pass to the command (optional).</param>
+        public static Task<object> InvokeCommandAsync(string commandName, JObject @params)
+        {
+            var handlerInfo = GetHandlerInfo(commandName);
+            var payload = @params ?? new JObject();
+
+            if (handlerInfo.IsAsync)
+            {
+                if (handlerInfo.AsyncHandler == null)
+                {
+                    throw new InvalidOperationException($"Async handler for '{commandName}' is not configured correctly");
+                }
+
+                return handlerInfo.AsyncHandler(payload);
+            }
+
+            if (handlerInfo.SyncHandler == null)
+            {
+                throw new InvalidOperationException($"Handler for '{commandName}' does not provide a synchronous implementation");
+            }
+
+            object result = handlerInfo.SyncHandler(payload);
+            return Task.FromResult(result);
+        }
+
         /// <summary>
         /// Create a delegate for an async handler method that returns Task or Task<T>.
         /// The delegate will invoke the method and await its completion, returning the result.

Server/src/services/tools/batch_execute.py

@@ -0,0 +1,78 @@
+"""Defines the batch_execute tool for orchestrating multiple Unity MCP commands."""
+from __future__ import annotations
+
+from typing import Annotated, Any
+
+from fastmcp import Context
+
+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
+
+MAX_COMMANDS_PER_BATCH = 25
+
+
+@mcp_for_unity_tool(
+    name="batch_execute",
+    description=(
+        "Runs a list of MCP tool calls as one batch. Use it to send a full sequence of commands, "
+        "inspect the results, then submit the next batch for the following step."
+    ),
+)
+async def batch_execute(
+    ctx: Context,
+    commands: Annotated[list[dict[str, Any]], "List of commands with 'tool' and 'params' keys."],
+    parallel: Annotated[bool | None, "Attempt to run read-only commands in parallel"] = None,
+    fail_fast: Annotated[bool | None, "Stop processing after the first failure"] = None,
+    max_parallelism: Annotated[int | None, "Hint for the maximum number of parallel workers"] = None,
+) -> dict[str, Any]:
+    """Proxy the batch_execute tool to the Unity Editor transporter."""
+    unity_instance = get_unity_instance_from_context(ctx)
+
+    if not isinstance(commands, list) or not commands:
+        raise ValueError("'commands' must be a non-empty list of command specifications")
+
+    if len(commands) > MAX_COMMANDS_PER_BATCH:
+        raise ValueError(
+            f"batch_execute currently supports up to {MAX_COMMANDS_PER_BATCH} commands; received {len(commands)}"
+        )
+
+    normalized_commands: list[dict[str, Any]] = []
+    for index, command in enumerate(commands):
+        if not isinstance(command, dict):
+            raise ValueError(f"Command at index {index} must be an object with 'tool' and 'params' keys")
+
+        tool_name = command.get("tool")
+        params = command.get("params", {})
+
+        if not tool_name or not isinstance(tool_name, str):
+            raise ValueError(f"Command at index {index} is missing a valid 'tool' name")
+
+        if params is None:
+            params = {}
+        if not isinstance(params, dict):
+            raise ValueError(f"Command '{tool_name}' must specify parameters as an object/dict")
+
+        normalized_commands.append({
+            "tool": tool_name,
+            "params": params,
+        })
+
+    payload: dict[str, Any] = {
+        "commands": normalized_commands,
+    }
+
+    if parallel is not None:
+        payload["parallel"] = bool(parallel)
+    if fail_fast is not None:
+        payload["failFast"] = bool(fail_fast)
+    if max_parallelism is not None:
+        payload["maxParallelism"] = int(max_parallelism)
+
+    return await send_with_unity_instance(
+        async_send_command_with_retry,
+        unity_instance,
+        "batch_execute",
+        payload,
+    )