@chrrxs/robloxstudio-mcp 2.16.0 → 2.16.1

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

@@ -7,6 +7,7 @@ import InputHandlers from "./handlers/InputHandlers";
 import EvalRuntimeHandlers from "./handlers/EvalRuntimeHandlers";
 import LuauExec from "./LuauExec";
 import State from "./State";
+import HttpDiagnostics from "./HttpDiagnostics";
 
 interface StudioTestServiceMultiplayer extends StudioTestService {
 	CanLeaveTest(): boolean;
@@ -64,7 +65,8 @@ function resolvePlaceName(): string {
 // is gone: stop now uses StopPlayMonitor with plugin:SetSetting cross-DM
 // signaling, which works regardless of MCP server state.)
 
-const MCP_URL = "http://localhost:58741";
+const DEFAULT_MCP_URL = "http://localhost:58741";
+let mcpUrl = DEFAULT_MCP_URL;
 const BROKER_NAME = "__MCPClientBroker";
 const BROKER_OWNER_ATTRIBUTE = "__MCPBrokerOwner";
 
@@ -152,7 +154,7 @@ function forkRole(): "edit" | "server" | "client" {
 function postJson(endpoint: string, body: Record<string, unknown>) {
 	return pcall(() =>
 		HttpService.RequestAsync({
-			Url: `${MCP_URL}${endpoint}`,
+			Url: `${mcpUrl}${endpoint}`,
 			Method: "POST",
 			Headers: { "Content-Type": "application/json" },
 			Body: HttpService.JSONEncode(body),
@@ -160,6 +162,20 @@ function postJson(endpoint: string, body: Record<string, unknown>) {
 	);
 }
 
+function formatPostJsonFailure(endpoint: string, ok: boolean, res: unknown): string {
+	return HttpDiagnostics.formatRequestFailure(`${mcpUrl}${endpoint}`, ok, res);
+}
+
+function setServerUrl(serverUrl: string | undefined): void {
+	if (serverUrl !== undefined && serverUrl !== "") {
+		mcpUrl = serverUrl;
+	}
+}
+
+function getServerUrl(): string {
+	return mcpUrl;
+}
+
 function handleExecuteLuau(data: Record<string, unknown> | undefined) {
 	const code = data && (data.code as string | undefined);
 	if (typeIs(code, "string") === false || code === "") {
@@ -277,13 +293,14 @@ function setupClientBroker() {
 }
 
 const proxyByPlayer = new Map<Player, ProxyEntry>();
+const proxyRegisterFailuresByPlayer = new Set<Player>();
 let serverBrokerStarted = false;
 
 function pollProxy(proxyId: string, player: Player, rf: RemoteFunction) {
 	while (player.Parent !== undefined && proxyByPlayer.has(player)) {
 		const [ok, res] = pcall(() =>
 			HttpService.RequestAsync({
-				Url: `${MCP_URL}/poll?pluginSessionId=${proxyId}`,
+				Url: `${mcpUrl}/poll?pluginSessionId=${proxyId}`,
 				Method: "GET",
 				Headers: { "Content-Type": "application/json" },
 			}),
@@ -341,18 +358,23 @@ function registerProxy(player: Player, rf: RemoteFunction) {
 		pluginVariant: State.PLUGIN_VARIANT,
 	});
 	if (!ok || !res || !res.Success) {
-		warn(`[robloxstudio-mcp] proxy register failed for ${player.Name}`);
+		proxyRegisterFailuresByPlayer.add(player);
+		warn(`[robloxstudio-mcp] proxy register failed for ${player.Name}: ${formatPostJsonFailure("/ready", ok, res)}`);
 		return;
 	}
 	const body = HttpService.JSONDecode(res.Body) as ReadyResponseBody;
 	const assigned = body.assignedRole ?? "client";
 	proxyByPlayer.set(player, { pluginSessionId: proxyId, role: assigned });
+	if (proxyRegisterFailuresByPlayer.has(player)) {
+		proxyRegisterFailuresByPlayer.delete(player);
+		print(`[robloxstudio-mcp] proxy registered for ${player.Name} as ${assigned} via ${mcpUrl}`);
+	}
 	task.spawn(pollProxy, proxyId, player, rf);
 }
 
 // (Removed: startEditProxyLoop. The play-server DM no longer registers an
 // "edit-proxy" peer with the MCP server. stop_playtest now uses a cross-DM
-// plugin:SetSetting flag consumed by StopPlayMonitor in the play-server DM,
+// plugin:SetSetting request consumed by StopPlayMonitor in the play-server DM,
 // which doesn't depend on MCP server state or peer registration at all.)
 
 function setupServerBroker() {
@@ -377,6 +399,7 @@ function setupServerBroker() {
 		const entry = proxyByPlayer.get(p);
 		if (entry) {
 			proxyByPlayer.delete(p);
+			proxyRegisterFailuresByPlayer.delete(p);
 			postJson("/disconnect", { pluginSessionId: entry.pluginSessionId });
 		}
 	});
@@ -389,7 +412,10 @@ function setupServerBroker() {
 }
 
 export = {
-	MCP_URL,
+	MCP_URL: DEFAULT_MCP_URL,
+	DEFAULT_MCP_URL,
+	getServerUrl,
+	setServerUrl,
 	forkRole,
 	setupClientBroker,
 	setupServerBroker,

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

@@ -18,6 +18,8 @@ import SerializationHandlers from "./handlers/SerializationHandlers";
 import MemoryHandlers from "./handlers/MemoryHandlers";
 import SceneAnalysisHandlers from "./handlers/SceneAnalysisHandlers";
 import EvalRuntimeHandlers from "./handlers/EvalRuntimeHandlers";
+import ServerUrlSettings from "./ServerUrlSettings";
+import HttpDiagnostics from "./HttpDiagnostics";
 import { Connection, RequestPayload, PollResponse, ReadyResponse } from "../types";
 
 // Per-plugin-load random GUID. Used as the /poll URL param so the server
@@ -50,6 +52,7 @@ let assignedRole: string | undefined;
 let duplicateInstanceRole = false;
 let hasVersionMismatch = false;
 let lastVersionMismatchWarningKey: string | undefined;
+const readyFailureLogKeys = new Set<string>();
 
 // Cache the published place name from MarketplaceService:GetProductInfo so
 // /ready can carry a friendly identifier (e.g. "Natural Disasters") distinct
@@ -249,30 +252,44 @@ function sendReady(conn: Connection): void {
 				}),
 			});
 		});
-		if (!readyOk) return;
-		// 409 = duplicate_instance_role. Surface in UI and stop polling.
-		if (readyResult.StatusCode === 409) {
-			duplicateInstanceRole = true;
-			conn.isActive = false;
-			const ui = UI.getElements();
-			if (State.getActiveTabIndex() === 0) {
-				ui.statusLabel.Text = "Duplicate instance";
-				ui.statusLabel.TextColor3 = Color3.fromRGB(239, 68, 68);
-				ui.detailStatusLabel.Text = "Another Studio is already connected as this place + role";
-				ui.detailStatusLabel.TextColor3 = Color3.fromRGB(239, 68, 68);
-			}
-			warn(
-				`[MCPPlugin] Another Studio is already connected as (${instanceId}, ${detectRole()}). Close the other Studio window or this one.`,
-			);
+		const readyUrl = `${conn.serverUrl}/ready`;
+		const readyRole = detectRole();
+		const readyLogKey = `${conn.serverUrl}|${instanceId}|${readyRole}`;
+		if (!readyOk) {
+			readyFailureLogKeys.add(readyLogKey);
+			warn(`[robloxstudio-mcp] /ready failed for ${instanceId}/${readyRole}: ${HttpDiagnostics.formatRequestFailure(readyUrl, readyOk, readyResult)}`);
 			return;
 		}
-		if (readyResult.Success) {
-			const [parseOk, readyData] = pcall(
-				() => HttpService.JSONDecode(readyResult.Body) as ReadyResponse,
-			);
-			if (parseOk && readyData.assignedRole) {
-				assignedRole = readyData.assignedRole;
+		if (!readyResult.Success) {
+			const reason = HttpDiagnostics.formatRequestFailure(readyUrl, true, readyResult);
+			readyFailureLogKeys.add(readyLogKey);
+			// 409 = duplicate_instance_role. Surface in UI and stop polling.
+			if (readyResult.StatusCode === 409) {
+				duplicateInstanceRole = true;
+				conn.isActive = false;
+				const ui = UI.getElements();
+				if (State.getActiveTabIndex() === 0) {
+					ui.statusLabel.Text = "Duplicate instance";
+					ui.statusLabel.TextColor3 = Color3.fromRGB(239, 68, 68);
+					ui.detailStatusLabel.Text = reason;
+					ui.detailStatusLabel.TextColor3 = Color3.fromRGB(239, 68, 68);
+				}
+				warn(`[robloxstudio-mcp] /ready rejected for ${instanceId}/${readyRole}: ${reason}`);
+				return;
 			}
+			warn(`[robloxstudio-mcp] /ready rejected for ${instanceId}/${readyRole}: ${reason}`);
+			return;
+		}
+		const [parseOk, readyData] = pcall(
+			() => HttpService.JSONDecode(readyResult.Body) as ReadyResponse,
+		);
+		if (parseOk && readyData.assignedRole) {
+			assignedRole = readyData.assignedRole;
+		}
+		const connectedRole = assignedRole ?? detectRole();
+		if (readyFailureLogKeys.has(readyLogKey)) {
+			readyFailureLogKeys.delete(readyLogKey);
+			print(`[robloxstudio-mcp] /ready connected for ${instanceId}/${connectedRole} via ${conn.serverUrl}`);
 		}
 	});
 }
@@ -313,7 +330,7 @@ function pollForRequests(connIndex: number) {
 			const warningKey = `${State.CURRENT_VERSION}:${serverVersion}`;
 			if (lastVersionMismatchWarningKey !== warningKey) {
 				lastVersionMismatchWarningKey = warningKey;
-				warn(`[MCPPlugin] Version mismatch: Studio plugin v${State.CURRENT_VERSION} / MCP v${serverVersion}. Run npx -y @chrrxs/robloxstudio-mcp@latest --auto-install-plugin and restart Studio.`);
+				warn(`[robloxstudio-mcp] Version mismatch: Studio plugin v${State.CURRENT_VERSION} / MCP v${serverVersion}. Run npx -y @chrrxs/robloxstudio-mcp@latest --auto-install-plugin and restart Studio.`);
 			}
 			UI.showBanner("version-mismatch", `Plugin v${State.CURRENT_VERSION} / MCP v${serverVersion} mismatch`);
 		} else if (hasVersionMismatch) {
@@ -470,6 +487,7 @@ function activatePlugin(connIndex?: number) {
 		UI.updateTabLabel(idx);
 		UI.updateUIState();
 	}
+	ServerUrlSettings.rememberServerUrl(conn.serverUrl);
 	UI.updateTabDot(idx);
 
 	if (!conn.heartbeatConnection) {

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

@@ -0,0 +1,50 @@
+import { HttpService } from "@rbxts/services";
+
+interface FailureBody {
+	error?: string;
+	message?: string;
+	missingFields?: unknown;
+	request?: unknown;
+	existing?: unknown;
+	details?: unknown;
+}
+
+function encodeForLog(value: unknown): string {
+	const [ok, encoded] = pcall(() => HttpService.JSONEncode(value));
+	return ok ? encoded : tostring(value);
+}
+
+function formatBody(body: string): string {
+	if (body === "") return "";
+	const [ok, decoded] = pcall(() => HttpService.JSONDecode(body));
+	if (ok && typeIs(decoded, "table")) {
+		const data = decoded as FailureBody;
+		const parts: string[] = [];
+		if (typeIs(data.error, "string") && data.error !== "") parts.push(`error=${data.error}`);
+		if (typeIs(data.message, "string") && data.message !== "") parts.push(`message=${data.message}`);
+		if (data.missingFields !== undefined) parts.push(`missingFields=${encodeForLog(data.missingFields)}`);
+		if (data.request !== undefined) parts.push(`request=${encodeForLog(data.request)}`);
+		if (data.existing !== undefined) parts.push(`existing=${encodeForLog(data.existing)}`);
+		if (data.details !== undefined) parts.push(`details=${encodeForLog(data.details)}`);
+		if (parts.size() > 0) return parts.join(" ");
+	}
+	return `body=${body}`;
+}
+
+function formatRequestFailure(url: string, ok: boolean, res: unknown): string {
+	if (!ok) {
+		return `RequestAsync threw for ${url}: ${tostring(res)}`;
+	}
+	if (res === undefined) {
+		return `RequestAsync returned no response for ${url}`;
+	}
+	const response = res as RequestAsyncResponse;
+	const statusMessage = response.StatusMessage !== "" ? ` ${response.StatusMessage}` : "";
+	const body = formatBody(response.Body);
+	const suffix = body !== "" ? `: ${body}` : "";
+	return `HTTP ${response.StatusCode}${statusMessage} from ${url}${suffix}`;
+}
+
+export = {
+	formatRequestFailure,
+};

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

@@ -0,0 +1,48 @@
+import { HttpService, ServerStorage } from "@rbxts/services";
+
+const SETTING_KEY_PREFIX = "MCP_SERVER_URL_";
+
+let pluginRef: Plugin | undefined;
+
+function init(p: Plugin): void {
+	pluginRef = p;
+}
+
+function computeInstanceId(): string {
+	if (game.PlaceId !== 0) {
+		return `place:${tostring(game.PlaceId)}`;
+	}
+	const existing = ServerStorage.GetAttribute("__MCPPlaceId");
+	if (typeIs(existing, "string") && existing !== "") {
+		return `anon:${existing as string}`;
+	}
+	const fresh = HttpService.GenerateGUID(false);
+	pcall(() => ServerStorage.SetAttribute("__MCPPlaceId", fresh));
+	return `anon:${fresh}`;
+}
+
+function settingKey(instanceId: string): string {
+	return SETTING_KEY_PREFIX + instanceId;
+}
+
+function rememberServerUrl(serverUrl: string): void {
+	if (!pluginRef || serverUrl === "") return;
+	const key = settingKey(computeInstanceId());
+	pcall(() => pluginRef!.SetSetting(key, serverUrl));
+}
+
+function readServerUrl(): string | undefined {
+	if (!pluginRef) return undefined;
+	const key = settingKey(computeInstanceId());
+	const [ok, value] = pcall(() => pluginRef!.GetSetting(key));
+	if (ok && typeIs(value, "string") && value !== "") {
+		return value as string;
+	}
+	return undefined;
+}
+
+export = {
+	init,
+	rememberServerUrl,
+	readServerUrl,
+};

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

@@ -5,39 +5,62 @@
 // `plugin:SetSetting` / `plugin:GetSetting` is a per-plugin persistent store
 // shared across every DataModel the plugin runs in (edit DMs, play-server
 // DMs, play-client DMs). For each connected place we use a dedicated key
-// "MCP_STOP_PLAY_<instanceId>" as a single-bit mailbox:
+// "MCP_STOP_PLAY_<instanceId>" as a tiny request/result mailbox:
 //
-//   * The edit DM's stopPlaytest handler writes `true` into its own key
+//   * The edit DM's handler writes a tokenized stop request into its own key
 //     (computed from its placeId / ServerStorage anon UUID).
 //   * Each play-server DM's monitor loop polls the key matching its own
-//     instanceId at 0.1Hz; on `true` it clears the key and calls
-//     StudioTestService:EndTest. Play-server DMs for other places never
-//     touch this key.
-//   * The edit DM waits up to ~8s for its key to be cleared, confirming a
-//     matching play-server actually consumed the request.
+//     instanceId at 1Hz. On a fresh token, it calls StudioTestService:EndTest
+//     and writes a matching result token. Play-server DMs for other places
+//     never touch this key.
+//   * The edit DM waits up to ~8s for its result token, confirming a matching
+//     play-server actually consumed the request.
 //
 // Earlier versions used a single shared boolean flag, which let any
 // play-server DM in the same Studio process consume any place's stop
 // request — silently yanking teammates' playtests. The per-key scoping
 // below is the fix.
 
-import { HttpService, ServerStorage } from "@rbxts/services";
+import { HttpService, RunService, ServerStorage } from "@rbxts/services";
 
 const StudioTestService = game.GetService("StudioTestService");
 
 const SETTING_KEY_PREFIX = "MCP_STOP_PLAY_";
-// Monitor checks the key at this cadence. 0.1s keeps worst-case detection
-// lag tight so the consumption-confirmation window doesn't have to absorb
-// polling jitter on top of EndTest's teardown time.
-const POLL_INTERVAL_SEC = 0.1;
+// Keep this conservative. plugin:GetSetting is backed by Studio's plugin
+// settings store, and this monitor runs during every play session, including
+// manually-started Play. The official reference implementation polls at 1s.
+const POLL_INTERVAL_SEC = 1;
 // Total time we wait for the matching play-server DM to consume the
 // signal. Must cover: monitor detection (<= POLL_INTERVAL_SEC) +
 // StudioTestService:EndTest teardown (several seconds on heavier places).
-// 8s is comfortable; the tighter poll above keeps real cases well under.
+// 8s is intentionally shorter than the MCP request timeout but long enough
+// for the 1s monitor cadence plus ordinary Studio teardown latency.
 const WAIT_FOR_CONSUMPTION_TIMEOUT_SEC = 8.0;
 const WAIT_POLL_SEC = 0.1;
+const REQUEST_TTL_SEC = 12.0;
 
 let pluginRef: Plugin | undefined;
+let endTestIssued = false;
+
+interface StopPayload {
+	kind?: string;
+	id?: string;
+	requestedAt?: number;
+	consumedAt?: number;
+	ok?: boolean;
+	error?: string;
+}
+
+interface StopRequestResult {
+	ok: boolean;
+	requestId?: string;
+}
+
+interface StopConsumptionResult {
+	ok: boolean;
+	consumed: boolean;
+	error?: string;
+}
 
 function init(p: Plugin): void {
 	pluginRef = p;
@@ -65,53 +88,147 @@ function settingKey(instanceId: string): string {
 	return SETTING_KEY_PREFIX + instanceId;
 }
 
+function readSetting(key: string): unknown {
+	if (!pluginRef) return undefined;
+	const [ok, value] = pcall(() => pluginRef!.GetSetting(key));
+	return ok ? value : undefined;
+}
+
+function writeSetting(key: string, value: unknown): boolean {
+	if (!pluginRef) return false;
+	const [ok] = pcall(() => pluginRef!.SetSetting(key, value));
+	return ok;
+}
+
+function decodePayload(value: unknown): StopPayload | undefined {
+	let decoded = value;
+	if (typeIs(value, "string")) {
+		const [ok, result] = pcall(() => HttpService.JSONDecode(value as string));
+		if (!ok) return undefined;
+		decoded = result;
+	}
+	if (!typeIs(decoded, "table")) return undefined;
+	const payload = decoded as StopPayload;
+	if (!typeIs(payload.kind, "string") || !typeIs(payload.id, "string")) {
+		return undefined;
+	}
+	return payload;
+}
+
+function writePayload(key: string, payload: StopPayload): boolean {
+	const [encodedOk, encoded] = pcall(() => HttpService.JSONEncode(payload));
+	if (!encodedOk || !typeIs(encoded, "string")) return false;
+	return writeSetting(key, encoded);
+}
+
+function writeResult(key: string, request: StopPayload, ok: boolean, errText?: string): void {
+	writePayload(key, {
+		kind: "result",
+		id: request.id,
+		requestedAt: request.requestedAt,
+		consumedAt: tick(),
+		ok,
+		error: errText,
+	});
+}
+
+function handleStopRequest(key: string, request: StopPayload): void {
+	if (request.kind !== "request" || !typeIs(request.id, "string")) return;
+	if (!typeIs(request.requestedAt, "number")) {
+		writeSetting(key, false);
+		return;
+	}
+
+	const age = tick() - request.requestedAt;
+	if (age < -5 || age > REQUEST_TTL_SEC) {
+		writeSetting(key, false);
+		return;
+	}
+
+	if (endTestIssued) {
+		writeResult(key, request, true);
+		return;
+	}
+
+	if (!RunService.IsRunning() || !RunService.IsServer()) {
+		writeResult(key, request, false, "StopPlayMonitor is not running in the server DataModel.");
+		return;
+	}
+
+	endTestIssued = true;
+	const [endOk, endErr] = pcall(() => StudioTestService.EndTest("stopped_by_mcp"));
+	writeResult(key, request, endOk, endOk ? undefined : tostring(endErr));
+	if (!endOk) {
+		endTestIssued = false;
+	}
+}
+
 function startMonitor(): void {
 	if (!pluginRef) {
-		warn("[MCP] StopPlayMonitor.startMonitor called before init; skipping");
+		warn("[robloxstudio-mcp] StopPlayMonitor.startMonitor called before init; skipping");
 		return;
 	}
 	const myKey = settingKey(computeInstanceId());
-	// Clear any stale value left from a prior session. If a real stop
-	// request is in-flight when this runs, the requesting edit DM will
-	// write again within its consumption-confirmation window.
-	pcall(() => pluginRef!.SetSetting(myKey, false));
 	task.spawn(() => {
 		while (true) {
-			const [okGet, val] = pcall(() => pluginRef!.GetSetting(myKey));
-			if (okGet && val === true) {
-				// Consume the flag first so requestStop's
-				// waitForConsumption returns success, then end the test.
-				pcall(() => pluginRef!.SetSetting(myKey, false));
-				pcall(() => StudioTestService.EndTest("stopped_by_mcp"));
+			const value = readSetting(myKey);
+			if (value === true) {
+				// Legacy boolean requests are ambiguous and may be stale from
+				// a prior crashed session. New stop requests use token payloads.
+				writeSetting(myKey, false);
+			} else {
+				const payload = decodePayload(value);
+				if (payload) {
+					handleStopRequest(myKey, payload);
+				}
 			}
 			task.wait(POLL_INTERVAL_SEC);
 		}
 	});
 }
 
-function requestStop(): boolean {
-	if (!pluginRef) return false;
+function requestStop(): StopRequestResult {
+	if (!pluginRef) return { ok: false };
 	const myKey = settingKey(computeInstanceId());
-	const [ok] = pcall(() => pluginRef!.SetSetting(myKey, true));
-	return ok;
+	const requestId = HttpService.GenerateGUID(false);
+	const ok = writePayload(myKey, {
+		kind: "request",
+		id: requestId,
+		requestedAt: tick(),
+	});
+	return { ok, requestId: ok ? requestId : undefined };
 }
 
-function waitForConsumption(): boolean {
-	if (!pluginRef) return false;
+function waitForConsumption(requestId: string): StopConsumptionResult {
+	if (!pluginRef) return { ok: false, consumed: false, error: "Plugin reference is not initialized." };
 	const myKey = settingKey(computeInstanceId());
 	const start = tick();
 	while (tick() - start < WAIT_FOR_CONSUMPTION_TIMEOUT_SEC) {
-		const [okGet, val] = pcall(() => pluginRef!.GetSetting(myKey));
-		if (okGet && val !== true) return true;
+		const payload = decodePayload(readSetting(myKey));
+		if (payload && payload.kind === "result" && payload.id === requestId) {
+			return {
+				ok: payload.ok === true,
+				consumed: true,
+				error: payload.error,
+			};
+		}
 		task.wait(WAIT_POLL_SEC);
 	}
-	return false;
+	return {
+		ok: false,
+		consumed: false,
+		error: "Timed out waiting for the play-server DataModel to acknowledge stop_playtest.",
+	};
 }
 
-function clearPending(): void {
+function clearPending(requestId?: string): void {
 	if (!pluginRef) return;
 	const myKey = settingKey(computeInstanceId());
-	pcall(() => pluginRef!.SetSetting(myKey, false));
+	if (requestId !== undefined) {
+		const payload = decodePayload(readSetting(myKey));
+		if (payload && payload.id !== requestId) return;
+	}
+	writeSetting(myKey, false);
 }
 
 export = {

package/studio-plugin/src/modules/handlers/TestHandlers.ts

@@ -231,7 +231,7 @@ function startPlaytest(requestData: Record<string, unknown>) {
 
 	const [injected, injErr] = pcall(() => injectStopListener());
 	if (!injected) {
-		warn(`[MCP] Failed to inject stop listener: ${injErr}`);
+		warn(`[robloxstudio-mcp] Failed to inject stop listener: ${injErr}`);
 	}
 
 	task.spawn(() => {
@@ -266,15 +266,15 @@ function startPlaytest(requestData: Record<string, unknown>) {
 }
 
 function stopPlaytest(_requestData: Record<string, unknown>) {
-	// Signal the play-server DM's StopPlayMonitor via plugin:SetSetting (a
-	// cross-DM persistent store). The monitor polls at 1Hz, sees the flag,
-	// calls StudioTestService:EndTest, then resets the flag. We wait up to
-	// 2.5s for the reset to confirm a play DM actually consumed the request,
-	// which avoids returning success when nothing is running.
-	if (!StopPlayMonitor.requestStop()) {
+	// Signal the play-server DM's StopPlayMonitor via plugin:SetSetting.
+	// The monitor acknowledges with the matching request id only after its
+	// StudioTestService:EndTest call returns from pcall.
+	const stopRequest = StopPlayMonitor.requestStop();
+	if (!stopRequest.ok || stopRequest.requestId === undefined) {
 		return { error: "Plugin not ready. Try again in a moment." };
 	}
-	if (!StopPlayMonitor.waitForConsumption()) {
+	const consumption = StopPlayMonitor.waitForConsumption(stopRequest.requestId);
+	if (!consumption.ok) {
 		// Two distinct failure modes collapse here, distinguished by whether
 		// THIS edit DM has a playtest tracked:
 		//
@@ -286,19 +286,24 @@ function stopPlaytest(_requestData: Record<string, unknown>) {
 		//   from the caller's perspective — playtest may actually have ended).
 		//   Tell the caller it's a timing issue and they can retry.
 		//
-		// Either way clean up the pending flag so a future playtest's monitor
+		// Either way clean up the pending request so a future playtest's monitor
 		// doesn't fire EndTest on startup against a stale signal.
-		StopPlayMonitor.clearPending();
+		StopPlayMonitor.clearPending(stopRequest.requestId);
 		if (testRunning) {
 			return {
 				error:
-					"Playtest stop signal sent but consumption confirmation timed out. " +
+					"Playtest stop signal failed or was not acknowledged. " +
 					"The playtest may have ended anyway; check get_connected_instances.",
+				detail: consumption.error,
 			};
 		}
-		return { error: "No active playtest to stop." };
+		if (consumption.consumed) {
+			return { error: "Playtest stop request reached the play server, but EndTest failed.", detail: consumption.error };
+		}
+		return { error: "No active playtest to stop.", detail: consumption.error };
 	}
-	// Flag was consumed (EndTest called). ExecutePlayModeAsync in our
+	StopPlayMonitor.clearPending(stopRequest.requestId);
+	// Request was consumed (EndTest called). ExecutePlayModeAsync in our
 	// startPlaytest task.spawn is still unwinding though — testRunning stays
 	// true until that yield completes and the post-block runs. Wait so
 	// back-to-back stop -> start sequences don't race against the prior

package/studio-plugin/src/server/index.server.ts

@@ -2,6 +2,7 @@ import State from "../modules/State";
 import UI from "../modules/UI";
 import Communication from "../modules/Communication";
 import ClientBroker from "../modules/ClientBroker";
+import ServerUrlSettings from "../modules/ServerUrlSettings";
 import { cleanupLegacyEditBridges, ensureRuntimeBridgeInstalled } from "../modules/EvalBridges";
 import RuntimeLogBuffer from "../modules/RuntimeLogBuffer";
 import StopPlayMonitor from "../modules/StopPlayMonitor";
@@ -21,6 +22,7 @@ RuntimeLogBuffer.install();
 // edit DM (write the flag) and the play-server DM (read+act on the flag) can
 // access plugin:SetSetting/GetSetting.
 StopPlayMonitor.init(plugin);
+ServerUrlSettings.init(plugin);
 
 UI.init(plugin);
 const elements = UI.getElements();
@@ -79,7 +81,7 @@ task.delay(2, () => {
 	} else {
 		const result = ensureRuntimeBridgeInstalled();
 		if (!result.installed) {
-			warn(`[MCPPlugin] Runtime eval bridge install failed: ${result.error}`);
+			warn(`[robloxstudio-mcp] Runtime eval bridge install failed: ${result.error}`);
 		}
 	}
 	if (role === "edit" || role === "server") {
@@ -87,10 +89,19 @@ task.delay(2, () => {
 			const idx = State.getActiveTabIndex();
 			const conn = State.getConnection(idx);
 			if (conn && !conn.isActive) {
+				if (role === "server") {
+					const inheritedServerUrl = ServerUrlSettings.readServerUrl() ?? ClientBroker.DEFAULT_MCP_URL;
+					conn.serverUrl = inheritedServerUrl;
+					elements.urlInput.Text = inheritedServerUrl;
+					const [portStr] = conn.serverUrl.match(":(%d+)$");
+					if (portStr) conn.port = tonumber(portStr) ?? conn.port;
+					ClientBroker.setServerUrl(inheritedServerUrl);
+				}
 				// Defensive default: in invisible play-DM UIs, the input field
 				// may not be populated by the time we activate.
 				if (conn.serverUrl === undefined || conn.serverUrl === "") {
-					conn.serverUrl = ClientBroker.MCP_URL;
+					conn.serverUrl = ClientBroker.DEFAULT_MCP_URL;
+					elements.urlInput.Text = conn.serverUrl;
 				}
 				Communication.activatePlugin(idx);
 			}
@@ -99,8 +110,8 @@ task.delay(2, () => {
 	if (role === "server") {
 		ClientBroker.setupServerBroker();
 		// The play-server DM is the only one where StudioTestService:EndTest is
-		// legal, so the stop-play monitor lives here. Reads MCP_STOP_PLAY_SIGNAL
-		// at 1Hz and calls EndTest when the edit DM sets it.
+		// legal, so the stop-play monitor lives here. It consumes tokenized
+		// stop requests from plugin settings and acknowledges EndTest results.
 		StopPlayMonitor.startMonitor();
 	} else if (role === "client") {
 		ClientBroker.setupClientBroker();