@chrrxs/robloxstudio-mcp 2.13.0 → 2.14.0

package/studio-plugin/MCPPlugin.rbxmx

@@ -105,6 +105,7 @@ local MemoryHandlers = TS.import(script, script.Parent, "handlers", "MemoryHandl
 local CaptureHandlers = TS.import(script, script.Parent, "handlers", "CaptureHandlers")
 local InputHandlers = TS.import(script, script.Parent, "handlers", "InputHandlers")
 local LuauExec = TS.import(script, script.Parent, "LuauExec")
+local StudioTestService = game:GetService("StudioTestService")
 -- Mirror of Communication.computeInstanceId() — duplicated here because the
 -- client broker runs in the play-server DM where it can't easily import from
 -- the edit-side module, and the place identifier must match what the edit-DM
@@ -158,6 +159,7 @@ end
 -- signaling, which works regardless of MCP server state.)
 local MCP_URL = "http://localhost:58741"
 local BROKER_NAME = "__MCPClientBroker"
+local BROKER_OWNER_ATTRIBUTE = "__MCPBrokerOwner"
 -- Endpoints the server-peer broker is allowed to forward to the client peer.
 -- Each requires the client peer's plugin VM (because the buffer / require
 -- cache / etc. lives there) so the server peer alone can't satisfy them.
@@ -165,6 +167,8 @@ local CLIENT_BROKER_ALLOWED_ENDPOINTS = {
 	["/api/execute-luau"] = true,
 	["/api/get-runtime-logs"] = true,
 	["/api/get-memory-breakdown"] = true,
+	["/api/multiplayer-test-state"] = true,
+	["/api/multiplayer-test-leave-client"] = true,
 	["/api/capture-begin"] = true,
 	["/api/simulate-mouse-input"] = true,
 	["/api/simulate-keyboard-input"] = true,
@@ -246,6 +250,77 @@ local function handleGetRuntimeLogs(data)
 		filter = filter,
 	}, "client")
 end
+local function handleMultiplayerTestState()
+	local argsOk, args = pcall(function()
+		return StudioTestService:GetTestArgs()
+	end)
+	local canLeaveOk, canLeave = pcall(function()
+		return StudioTestService:CanLeaveTest()
+	end)
+	local _exp = Players:GetPlayers()
+	-- ▼ ReadonlyArray.map ▼
+	local _newValue = table.create(#_exp)
+	local _callback = function(player)
+		return {
+			name = player.Name,
+			userId = player.UserId,
+			displayName = player.DisplayName,
+		}
+	end
+	for _k, _v in _exp do
+		_newValue[_k] = _callback(_v, _k - 1, _exp)
+	end
+	-- ▲ ReadonlyArray.map ▲
+	local players = _newValue
+	table.sort(players, function(a, b)
+		return a.name < b.name
+	end)
+	return {
+		success = true,
+		peer = "client",
+		isRunning = RunService:IsRunning(),
+		isRunMode = RunService:IsRunMode(),
+		editModeActive = StudioTestService.EditModeActive,
+		testArgsOk = argsOk,
+		testArgs = if argsOk then args else nil,
+		testArgsError = if argsOk then nil else tostring(args),
+		players = players,
+		playerCount = #players,
+		localPlayer = if Players.LocalPlayer then Players.LocalPlayer.Name else nil,
+		canLeaveOk = canLeaveOk,
+		canLeave = if canLeaveOk then canLeave else false,
+		canLeaveError = if canLeaveOk then nil else tostring(canLeave),
+	}
+end
+local function handleMultiplayerTestLeaveClient()
+	local canLeaveOk, canLeave = pcall(function()
+		return StudioTestService:CanLeaveTest()
+	end)
+	if not canLeaveOk then
+		return {
+			error = tostring(canLeave),
+			canLeaveOk = false,
+		}
+	end
+	if not canLeave then
+		return {
+			error = "This client cannot leave the current test session.",
+			canLeaveOk = true,
+			canLeave = false,
+		}
+	end
+	local localPlayer = if Players.LocalPlayer then Players.LocalPlayer.Name else nil
+	task.defer(function()
+		pcall(function()
+			return StudioTestService:LeaveTest()
+		end)
+	end)
+	return {
+		success = true,
+		message = "Client leave requested.",
+		localPlayer = localPlayer,
+	}
+end
 local function setupClientBroker()
 	local rf = ReplicatedStorage:WaitForChild(BROKER_NAME, 10)
 	if not rf or not rf:IsA("RemoteFunction") then
@@ -265,6 +340,12 @@ local function setupClientBroker()
 		if payload and payload.endpoint == "/api/get-memory-breakdown" then
 			return MemoryHandlers.getMemoryBreakdown(payload.data or {})
 		end
+		if payload and payload.endpoint == "/api/multiplayer-test-state" then
+			return handleMultiplayerTestState()
+		end
+		if payload and payload.endpoint == "/api/multiplayer-test-leave-client" then
+			return handleMultiplayerTestLeaveClient()
+		end
 		if payload and payload.endpoint == "/api/capture-begin" then
 			return CaptureHandlers.captureBegin()
 		end
@@ -282,6 +363,7 @@ local function setupClientBroker()
 	end
 end
 local proxyByPlayer = {}
+local serverBrokerStarted = false
 local function pollProxy(proxyId, player, rf)
 	while true do
 		local _condition = player.Parent ~= nil
@@ -393,12 +475,20 @@ end
 -- plugin:SetSetting flag consumed by StopPlayMonitor in the play-server DM,
 -- which doesn't depend on MCP server state or peer registration at all.)
 local function setupServerBroker()
+	if serverBrokerStarted then
+		return nil
+	end
 	local rf = ReplicatedStorage:FindFirstChild(BROKER_NAME)
 	if not rf then
 		rf = Instance.new("RemoteFunction")
 		rf.Name = BROKER_NAME
 		rf.Parent = ReplicatedStorage
 	end
+	if rf:GetAttribute(BROKER_OWNER_ATTRIBUTE) ~= nil then
+		return nil
+	end
+	rf:SetAttribute(BROKER_OWNER_ATTRIBUTE, HttpService:GenerateGUID(false))
+	serverBrokerStarted = true
 	local broker = rf
 	Players.PlayerAdded:Connect(function(p)
 		return registerProxy(p, broker)
@@ -571,6 +661,11 @@ local routeMap = {
 	["/api/start-playtest"] = TestHandlers.startPlaytest,
 	["/api/stop-playtest"] = TestHandlers.stopPlaytest,
 	["/api/get-playtest-output"] = TestHandlers.getPlaytestOutput,
+	["/api/multiplayer-test-start"] = TestHandlers.multiplayerTestStart,
+	["/api/multiplayer-test-state"] = TestHandlers.multiplayerTestState,
+	["/api/multiplayer-test-add-players"] = TestHandlers.multiplayerTestAddPlayers,
+	["/api/multiplayer-test-leave-client"] = TestHandlers.multiplayerTestLeaveClient,
+	["/api/multiplayer-test-end"] = TestHandlers.multiplayerTestEnd,
 	["/api/character-navigation"] = TestHandlers.characterNavigation,
 	["/api/export-build"] = BuildHandlers.exportBuild,
 	["/api/import-build"] = BuildHandlers.importBuild,
@@ -1161,9 +1256,9 @@ local function computeBridgeStamp()
 	for i = 1, #combined do
 		h = (h * 33 + (string.byte(combined, i))) % 2147483647
 	end
-	-- "2.13.0" is replaced with the package version at package time
+	-- "2.14.0" is replaced with the package version at package time
 	-- (scripts/build-plugin.mjs injectVersion), so a release bump also restamps.
-	return `{tostring(h)}-2.13.0`
+	return `{tostring(h)}-2.14.0`
 end
 local BRIDGE_STAMP = computeBridgeStamp()
 local function setSource(scriptInst, source)
@@ -5864,6 +5959,7 @@ local TS = require(script.Parent.Parent.Parent.include.RuntimeLib)
 local _services = TS.import(script, script.Parent.Parent.Parent, "node_modules", "@rbxts", "services")
 local HttpService = _services.HttpService
 local LogService = _services.LogService
+local Players = _services.Players
 local RunService = _services.RunService
 local _EvalBridges = TS.import(script, script.Parent.Parent, "EvalBridges")
 local installBridges = _EvalBridges.installBridges
@@ -5885,6 +5981,63 @@ local testResult
 local testError
 local stopListenerScript
 local navResultCallback
+local multiplayerState = {
+	phase = "idle",
+}
+local function detectPeerRole()
+	if not RunService:IsRunning() then
+		return "edit"
+	end
+	if RunService:IsServer() then
+		return "server"
+	end
+	return "client"
+end
+local function getPlayersSnapshot()
+	local _exp = Players:GetPlayers()
+	-- ▼ ReadonlyArray.map ▼
+	local _newValue = table.create(#_exp)
+	local _callback = function(player)
+		return {
+			name = player.Name,
+			userId = player.UserId,
+			displayName = player.DisplayName,
+		}
+	end
+	for _k, _v in _exp do
+		_newValue[_k] = _callback(_v, _k - 1, _exp)
+	end
+	-- ▲ ReadonlyArray.map ▲
+	local players = _newValue
+	table.sort(players, function(a, b)
+		return a.name < b.name
+	end)
+	return players
+end
+local function cloneMultiplayerState()
+	return {
+		phase = multiplayerState.phase,
+		testId = multiplayerState.testId,
+		numPlayers = multiplayerState.numPlayers,
+		testArgs = multiplayerState.testArgs,
+		startedAt = multiplayerState.startedAt,
+		completedAt = multiplayerState.completedAt,
+		ok = multiplayerState.ok,
+		result = multiplayerState.result,
+		error = multiplayerState.error,
+	}
+end
+local function normalizeNumPlayers(value)
+	local _value = value
+	if not (type(_value) == "number") then
+		return nil
+	end
+	local n = math.floor(value)
+	if n ~= value or n < 1 or n > 8 then
+		return nil
+	end
+	return n
+end
 local function buildCommandListenerSource()
 	return `local LogService = game:GetService("LogService")\
 local PathfindingService = game:GetService("PathfindingService")\
@@ -5981,6 +6134,11 @@ local function startPlaytest(requestData)
 			error = 'mode must be "play" or "run"',
 		}
 	end
+	if numPlayers ~= nil then
+		return {
+			error = "start_playtest is single-player only. Use multiplayer_test_start for multi-client StudioTestService sessions.",
+		}
+	end
 	-- Self-heal: if testRunning is stuck true but Studio reports no active
 	-- playtest, the previous start_playtest's task.spawn was orphaned
 	-- (plugin reload mid-test, Studio entered some inconsistent state, etc).
@@ -6045,10 +6203,6 @@ local function startPlaytest(requestData)
 	if not bridgeInstall.installed then
 		warn(`[MCP] Eval bridge install failed: {bridgeInstall.error}`)
 	end
-	if numPlayers ~= nil and mode == "run" then
-		local TestService = game:GetService("TestService")
-		TestService.NumberOfPlayers = math.clamp(numPlayers, 1, 8)
-	end
 	task.spawn(function()
 		local ok, result = pcall(function()
 			if mode == "play" then
@@ -6071,10 +6225,9 @@ local function startPlaytest(requestData)
 		-- clean up here, so the next manual playtest still gets them.
 		ensureBridgesInstalled()
 	end)
-	local msg = if numPlayers ~= nil then `Playtest started in {mode} mode with {numPlayers} player(s).` else `Playtest started in {mode} mode.`
 	local response = {
 		success = true,
-		message = msg,
+		message = `Playtest started in {mode} mode.`,
 	}
 	-- Only mention eval bridges when they failed — when they're fine, the
 	-- detail is noise. eval_server_runtime / eval_client_runtime will surface
@@ -6157,6 +6310,198 @@ local function getPlaytestOutput(_requestData)
 	_object.testError = testError
 	return _object
 end
+local function multiplayerTestStart(requestData)
+	if RunService:IsRunning() then
+		return {
+			error = "multiplayer_test_start must be called on the edit DataModel. Route with target=edit.",
+		}
+	end
+	local numPlayers = normalizeNumPlayers(requestData.numPlayers)
+	if numPlayers == nil then
+		return {
+			error = "numPlayers must be an integer from 1 to 8",
+		}
+	end
+	if multiplayerState.phase == "starting" or multiplayerState.phase == "running" then
+		return {
+			error = "A multiplayer Studio test is already running",
+			state = cloneMultiplayerState(),
+		}
+	end
+	local testArgs = if requestData.testArgs ~= nil then requestData.testArgs else {}
+	local testId = HttpService:GenerateGUID(false)
+	local bridgeInstall = installBridges()
+	if not bridgeInstall.installed then
+		warn(`[MCP] Eval bridge install failed: {bridgeInstall.error}`)
+	end
+	multiplayerState = {
+		phase = "starting",
+		testId = testId,
+		numPlayers = numPlayers,
+		testArgs = testArgs,
+		startedAt = tick(),
+	}
+	task.spawn(function()
+		multiplayerState.phase = "running"
+		local ok, result = pcall(function()
+			return StudioTestService:ExecuteMultiplayerTestAsync(numPlayers, testArgs)
+		end)
+		multiplayerState.completedAt = tick()
+		multiplayerState.ok = ok
+		if ok then
+			multiplayerState.phase = "completed"
+			multiplayerState.result = result
+			multiplayerState.error = nil
+		else
+			multiplayerState.phase = "failed"
+			multiplayerState.result = nil
+			multiplayerState.error = tostring(result)
+		end
+		ensureBridgesInstalled()
+	end)
+	local response = {
+		success = true,
+		message = `Multiplayer Studio test starting with {numPlayers} player(s).`,
+		testId = testId,
+		phase = multiplayerState.phase,
+		numPlayers = numPlayers,
+		testArgs = testArgs,
+	}
+	if not bridgeInstall.installed then
+		response.evalBridgesError = bridgeInstall.error
+	end
+	return response
+end
+local function multiplayerTestState(_requestData)
+	local peer = detectPeerRole()
+	local response = {
+		success = true,
+		peer = peer,
+		isRunning = RunService:IsRunning(),
+		isRunMode = RunService:IsRunMode(),
+		editModeActive = StudioTestService.EditModeActive,
+	}
+	if peer == "edit" then
+		response.session = cloneMultiplayerState()
+		return response
+	end
+	local argsOk, args = pcall(function()
+		return StudioTestService:GetTestArgs()
+	end)
+	response.testArgsOk = argsOk
+	response.testArgs = if argsOk then args else nil
+	if not argsOk then
+		response.testArgsError = tostring(args)
+	end
+	local players = getPlayersSnapshot()
+	response.players = players
+	response.playerCount = #players
+	if peer == "client" then
+		response.localPlayer = if Players.LocalPlayer then Players.LocalPlayer.Name else nil
+		local canLeaveOk, canLeave = pcall(function()
+			return StudioTestService:CanLeaveTest()
+		end)
+		response.canLeaveOk = canLeaveOk
+		response.canLeave = if canLeaveOk then canLeave else false
+		if not canLeaveOk then
+			response.canLeaveError = tostring(canLeave)
+		end
+	end
+	return response
+end
+local function multiplayerTestAddPlayers(requestData)
+	if not RunService:IsRunning() or not RunService:IsServer() then
+		return {
+			error = "multiplayer_test_add_players must be called on the running server peer. Route with target=server.",
+		}
+	end
+	local numPlayers = normalizeNumPlayers(requestData.numPlayers)
+	if numPlayers == nil then
+		return {
+			error = "numPlayers must be an integer from 1 to 8",
+		}
+	end
+	local before = #Players:GetPlayers()
+	local ok, result = pcall(function()
+		return StudioTestService:AddPlayers(numPlayers)
+	end)
+	if not ok then
+		return {
+			error = tostring(result),
+		}
+	end
+	local _exp = tick()
+	local _condition = (requestData.timeout)
+	if _condition == nil then
+		_condition = 10
+	end
+	local deadline = _exp + _condition
+	while #Players:GetPlayers() < before + numPlayers and tick() < deadline do
+		task.wait(0.1)
+	end
+	local players = getPlayersSnapshot()
+	return {
+		success = true,
+		message = `Requested {numPlayers} additional player(s).`,
+		playerCount = #players,
+		players = players,
+	}
+end
+local function multiplayerTestLeaveClient(_requestData)
+	if not RunService:IsRunning() or RunService:IsServer() then
+		return {
+			error = "multiplayer_test_leave_client must be called on a running client peer. Route with target=client-N.",
+		}
+	end
+	local canLeaveOk, canLeave = pcall(function()
+		return StudioTestService:CanLeaveTest()
+	end)
+	if not canLeaveOk then
+		return {
+			error = tostring(canLeave),
+			canLeaveOk = false,
+		}
+	end
+	if not canLeave then
+		return {
+			error = "This client cannot leave the current test session.",
+			canLeaveOk = true,
+			canLeave = false,
+		}
+	end
+	local localPlayer = if Players.LocalPlayer then Players.LocalPlayer.Name else nil
+	task.defer(function()
+		pcall(function()
+			return StudioTestService:LeaveTest()
+		end)
+	end)
+	return {
+		success = true,
+		message = "Client leave requested.",
+		localPlayer = localPlayer,
+	}
+end
+local function multiplayerTestEnd(requestData)
+	if not RunService:IsRunning() or not RunService:IsServer() then
+		return {
+			error = "multiplayer_test_end must be called on the running server peer. Route with target=server.",
+		}
+	end
+	local value = if requestData.value ~= nil then requestData.value else "ended_by_mcp"
+	local ok, result = pcall(function()
+		return StudioTestService:EndTest(value)
+	end)
+	if not ok then
+		return {
+			error = tostring(result),
+		}
+	end
+	return {
+		success = true,
+		message = "Multiplayer Studio test end requested.",
+		value = value,
+	}
+end
 local function characterNavigation(requestData)
 	if not testRunning then
 		return {
@@ -6228,6 +6573,11 @@ return {
 	startPlaytest = startPlaytest,
 	stopPlaytest = stopPlaytest,
 	getPlaytestOutput = getPlaytestOutput,
+	multiplayerTestStart = multiplayerTestStart,
+	multiplayerTestState = multiplayerTestState,
+	multiplayerTestAddPlayers = multiplayerTestAddPlayers,
+	multiplayerTestLeaveClient = multiplayerTestLeaveClient,
+	multiplayerTestEnd = multiplayerTestEnd,
 	characterNavigation = characterNavigation,
 }
 ]]></string>
@@ -6835,7 +7185,7 @@ return {
         <Properties>
           <string name="Name">State</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
-local CURRENT_VERSION = "2.13.0"
+local CURRENT_VERSION = "2.14.0"
 local MAX_CONNECTIONS = 5
 local BASE_PORT = 58741
 local activeTabIndex = 0

package/studio-plugin/src/modules/ClientBroker.ts

@@ -5,6 +5,14 @@ import CaptureHandlers from "./handlers/CaptureHandlers";
 import InputHandlers from "./handlers/InputHandlers";
 import LuauExec from "./LuauExec";
 
+interface StudioTestServiceMultiplayer extends StudioTestService {
+	CanLeaveTest(): boolean;
+	LeaveTest(): void;
+	EditModeActive: boolean;
+}
+
+const StudioTestService = game.GetService("StudioTestService") as StudioTestServiceMultiplayer;
+
 // Mirror of Communication.computeInstanceId() — duplicated here because the
 // client broker runs in the play-server DM where it can't easily import from
 // the edit-side module, and the place identifier must match what the edit-DM
@@ -55,6 +63,7 @@ function resolvePlaceName(): string {
 
 const MCP_URL = "http://localhost:58741";
 const BROKER_NAME = "__MCPClientBroker";
+const BROKER_OWNER_ATTRIBUTE = "__MCPBrokerOwner";
 
 interface ProxyEntry {
 	pluginSessionId: string;
@@ -78,6 +87,8 @@ const CLIENT_BROKER_ALLOWED_ENDPOINTS = new Set<string>([
 	"/api/execute-luau",
 	"/api/get-runtime-logs",
 	"/api/get-memory-breakdown",
+	"/api/multiplayer-test-state",
+	"/api/multiplayer-test-leave-client",
 	// Screenshot capture must run in the client peer (CaptureService captures
 	// the play viewport there); the edit DM reads the temp id back separately.
 	"/api/capture-begin",
@@ -164,6 +175,52 @@ function handleGetRuntimeLogs(data: Record<string, unknown> | undefined): unknow
 	return RuntimeLogBuffer.query({ since, tail, filter }, "client");
 }
 
+function handleMultiplayerTestState(): unknown {
+	const [argsOk, args] = pcall(() => StudioTestService.GetTestArgs());
+	const [canLeaveOk, canLeave] = pcall(() => StudioTestService.CanLeaveTest());
+	const players = Players.GetPlayers().map((player) => ({
+		name: player.Name,
+		userId: player.UserId,
+		displayName: player.DisplayName,
+	}));
+	players.sort((a, b) => a.name < b.name);
+	return {
+		success: true,
+		peer: "client",
+		isRunning: RunService.IsRunning(),
+		isRunMode: RunService.IsRunMode(),
+		editModeActive: StudioTestService.EditModeActive,
+		testArgsOk: argsOk,
+		testArgs: argsOk ? args : undefined,
+		testArgsError: argsOk ? undefined : tostring(args),
+		players,
+		playerCount: players.size(),
+		localPlayer: Players.LocalPlayer ? Players.LocalPlayer.Name : undefined,
+		canLeaveOk,
+		canLeave: canLeaveOk ? canLeave : false,
+		canLeaveError: canLeaveOk ? undefined : tostring(canLeave),
+	};
+}
+
+function handleMultiplayerTestLeaveClient(): unknown {
+	const [canLeaveOk, canLeave] = pcall(() => StudioTestService.CanLeaveTest());
+	if (!canLeaveOk) {
+		return { error: tostring(canLeave), canLeaveOk: false };
+	}
+	if (!canLeave) {
+		return { error: "This client cannot leave the current test session.", canLeaveOk: true, canLeave: false };
+	}
+	const localPlayer = Players.LocalPlayer ? Players.LocalPlayer.Name : undefined;
+	task.defer(() => {
+		pcall(() => StudioTestService.LeaveTest());
+	});
+	return {
+		success: true,
+		message: "Client leave requested.",
+		localPlayer,
+	};
+}
+
 function setupClientBroker() {
 	const rf = ReplicatedStorage.WaitForChild(BROKER_NAME, 10);
 	if (!rf || !rf.IsA("RemoteFunction")) {
@@ -183,6 +240,12 @@ function setupClientBroker() {
 		if (payload && payload.endpoint === "/api/get-memory-breakdown") {
 			return MemoryHandlers.getMemoryBreakdown(payload.data ?? {});
 		}
+		if (payload && payload.endpoint === "/api/multiplayer-test-state") {
+			return handleMultiplayerTestState();
+		}
+		if (payload && payload.endpoint === "/api/multiplayer-test-leave-client") {
+			return handleMultiplayerTestLeaveClient();
+		}
 		if (payload && payload.endpoint === "/api/capture-begin") {
 			return CaptureHandlers.captureBegin();
 		}
@@ -201,6 +264,7 @@ function setupClientBroker() {
 }
 
 const proxyByPlayer = new Map<Player, ProxyEntry>();
+let serverBrokerStarted = false;
 
 function pollProxy(proxyId: string, player: Player, rf: RemoteFunction) {
 	while (player.Parent !== undefined && proxyByPlayer.has(player)) {
@@ -277,12 +341,18 @@ function registerProxy(player: Player, rf: RemoteFunction) {
 // which doesn't depend on MCP server state or peer registration at all.)
 
 function setupServerBroker() {
+	if (serverBrokerStarted) return;
 	let rf = ReplicatedStorage.FindFirstChild(BROKER_NAME) as RemoteFunction | undefined;
 	if (!rf) {
 		rf = new Instance("RemoteFunction");
 		rf.Name = BROKER_NAME;
 		rf.Parent = ReplicatedStorage;
 	}
+	if (rf.GetAttribute(BROKER_OWNER_ATTRIBUTE) !== undefined) {
+		return;
+	}
+	rf.SetAttribute(BROKER_OWNER_ATTRIBUTE, HttpService.GenerateGUID(false));
+	serverBrokerStarted = true;
 	const broker = rf;
 	Players.PlayerAdded.Connect((p) => registerProxy(p, broker));
 	for (const p of Players.GetPlayers()) {

package/studio-plugin/src/modules/Communication.ts

@@ -133,6 +133,11 @@ const routeMap: Record<string, Handler> = {
 	"/api/start-playtest": TestHandlers.startPlaytest,
 	"/api/stop-playtest": TestHandlers.stopPlaytest,
 	"/api/get-playtest-output": TestHandlers.getPlaytestOutput,
+	"/api/multiplayer-test-start": TestHandlers.multiplayerTestStart,
+	"/api/multiplayer-test-state": TestHandlers.multiplayerTestState,
+	"/api/multiplayer-test-add-players": TestHandlers.multiplayerTestAddPlayers,
+	"/api/multiplayer-test-leave-client": TestHandlers.multiplayerTestLeaveClient,
+	"/api/multiplayer-test-end": TestHandlers.multiplayerTestEnd,
 	"/api/character-navigation": TestHandlers.characterNavigation,
 
 	"/api/export-build": BuildHandlers.exportBuild,