@chrrxs/robloxstudio-mcp 3.1.0 → 3.1.2

package/dist/index.js

@@ -1939,10 +1939,82 @@ import { serveStdio } from "@modelcontextprotocol/server/stdio";
 // ../core/dist/http-server.js
 import express from "express";
 import http from "http";
+import { randomBytes as randomBytes2 } from "crypto";
+import { WebSocketServer } from "ws";
 import { toNodeHandler } from "@modelcontextprotocol/node";
 
 // ../core/dist/bridge-service.js
-import { randomUUID } from "crypto";
+import { createHash, randomUUID } from "crypto";
+function isExecutionOutcome(value) {
+  return value === "success" || value === "error" || value === "not_executed" || value === "unknown";
+}
+function isRequestStage(value) {
+  return value === "queued" || value === "dispatched" || value === "executing" || value === "response_delivery";
+}
+function handlerOutcome(response) {
+  if (!response || typeof response !== "object")
+    return "success";
+  if ("error" in response && response.error !== void 0 && response.error !== null || "success" in response && response.success === false || "ok" in response && response.ok === false)
+    return "error";
+  if ("summary" in response && response.summary && typeof response.summary === "object" && "failed" in response.summary && typeof response.summary.failed === "number" && response.summary.failed > 0)
+    return "error";
+  return "success";
+}
+function observations(status) {
+  return {
+    executionStartedAt: status.executionStartedAt,
+    executionCompletedAt: status.executionCompletedAt,
+    executionOutcome: status.executionOutcome,
+    connectionLostAt: status.connectionLostAt,
+    connectionRestoredAt: status.connectionRestoredAt
+  };
+}
+var RequestFailure = class extends Error {
+  code;
+  details;
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "RequestFailure";
+  }
+};
+function parseObservations(value) {
+  const result = {};
+  if ("executionOutcome" in value) {
+    if (!isExecutionOutcome(value.executionOutcome))
+      throw new Error("Invalid execution outcome");
+    result.executionOutcome = value.executionOutcome;
+  }
+  for (const key of ["executionStartedAt", "executionCompletedAt", "connectionLostAt", "connectionRestoredAt"]) {
+    if (!(key in value))
+      continue;
+    const timestamp = Reflect.get(value, key);
+    if (typeof timestamp !== "number" || !Number.isFinite(timestamp))
+      throw new Error("Invalid observation timestamp");
+    result[key] = timestamp;
+  }
+  return result;
+}
+function parseFailureDetails(value, identity) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return void 0;
+  const isHttpRejection = "transportStage" in value && value.transportStage === "http_receive";
+  const requestId = "requestId" in value ? value.requestId : isHttpRejection ? identity.requestId : void 0;
+  const targetPeerId = "targetPeerId" in value ? value.targetPeerId : isHttpRejection ? identity.targetPeerId : void 0;
+  if (typeof requestId !== "string" || typeof targetPeerId !== "string" || requestId !== identity.requestId || targetPeerId !== identity.targetPeerId || !("stage" in value) || !isRequestStage(value.stage) || !("outcome" in value) || value.outcome !== "not_executed" && value.outcome !== "unknown")
+    return void 0;
+  return {
+    requestId,
+    targetPeerId,
+    stage: value.stage,
+    outcome: value.outcome,
+    ...parseObservations(value),
+    ..."bytes" in value && typeof value.bytes === "number" ? { bytes: value.bytes } : {},
+    ..."limitBytes" in value && typeof value.limitBytes === "number" ? { limitBytes: value.limitBytes } : {},
+    ..."transportStage" in value && (value.transportStage === "server_send" || value.transportStage === "proxy_send" || value.transportStage === "http_receive") ? { transportStage: value.transportStage } : {}
+  };
+}
 var RoutingFailure = class extends Error {
   routingError;
   constructor(routingError) {
@@ -1970,11 +2042,16 @@ function toPublicPeer(peer) {
   };
 }
 var STALE_PEER_MS = 3e4;
-var ACCEPTED_REQUEST_TOMBSTONE_TTL_MS = 6e4;
-var MAX_ACCEPTED_REQUEST_TOMBSTONES = 4096;
+var OPERATION_RETENTION_MS = 5 * 6e4;
+var MAX_OPERATION_RECORDS = 32768;
+var MAX_RETAINED_RESULTS = 1024;
+var MAX_RETAINED_RESULT_BYTES = 64 * 1024 * 1024;
+var MAX_REQUEST_BYTES = 64 * 1024 * 1024;
+var MAX_PENDING_REQUESTS = 1024;
+var MAX_PENDING_REQUEST_BYTES = 64 * 1024 * 1024;
 var CANCELLATION_TOMBSTONE_TTL_MS = 6e4;
 var MAX_CANCELLATION_TOMBSTONES = 4096;
-var MAX_OUTSTANDING_REQUESTS_PER_DELIVERY_OWNER = 4;
+var MAX_OUTSTANDING_REQUESTS_PER_TRANSPORT = 4;
 function roleOrder(role) {
   if (role === "edit")
     return 0;
@@ -2005,7 +2082,10 @@ function copyGroup(group) {
 }
 var BridgeService = class {
   pendingRequests = /* @__PURE__ */ new Map();
-  acceptedRequestIds = /* @__PURE__ */ new Map();
+  operations = /* @__PURE__ */ new Map();
+  retainedResults = /* @__PURE__ */ new Map();
+  retainedResultBytes = 0;
+  pendingRequestBytes = 0;
   pendingCancellations = /* @__PURE__ */ new Map();
   peersById = /* @__PURE__ */ new Map();
   multiplayerGroupsById = /* @__PURE__ */ new Map();
@@ -2048,13 +2128,25 @@ var BridgeService = class {
         this.deliveryOwnersByTransportPeer.set(transportPeerId, owners);
       }
       owners.add(owner);
+      for (const operation of this.operations.values()) {
+        if (operation.transportPeerId === transportPeerId && operation.status.state !== "settled" && operation.status.connectionLostAt !== void 0 && operation.status.connectionRestoredAt === void 0) {
+          operation.status.connectionRestoredAt = Date.now();
+        }
+      }
       return;
     }
     if (!owners)
       return;
     owners.delete(owner);
-    if (owners.size === 0)
+    if (owners.size === 0) {
       this.deliveryOwnersByTransportPeer.delete(transportPeerId);
+      for (const operation of this.operations.values()) {
+        if (operation.transportPeerId !== transportPeerId || operation.status.state === "settled")
+          continue;
+        operation.status.connectionLostAt = Date.now();
+        delete operation.status.connectionRestoredAt;
+      }
+    }
   }
   notifyRequestAvailable(transportPeerId) {
     for (const listener of this.requestAvailableListeners) {
@@ -2285,8 +2377,7 @@ var BridgeService = class {
       if (request.targetPeerId !== peerId)
         continue;
       const deliveryTransportPeerId = request.lastDeliveryTransportPeerId;
-      this.removePendingRequest(request);
-      request.reject(new Error(`Target Peer "${peerId}" disconnected`));
+      this.endRequestWaiter(request, "disconnected", `Target Peer "${peerId}" disconnected`);
       if (deliveryTransportPeerId)
         this.notifyRequestAvailable(deliveryTransportPeerId);
     }
@@ -2545,44 +2636,126 @@ var BridgeService = class {
     const peers = this.getPeers().filter((peer) => this.peerScopeKey(peer) === onlyScope);
     return this.resolveWithinScope(peers, input.target, errorData);
   }
-  sendRequest(endpoint, data, targetPeerId, timeoutMs = this.requestTimeout, signal) {
-    const requestId = randomUUID();
+  sendRequest(endpoint, data, targetPeerId, timeoutMs = this.requestTimeout, signal, operationId) {
+    const requestId = operationId ?? randomUUID();
     const effectiveTimeoutMs = Math.max(1, timeoutMs);
-    if (signal?.aborted)
-      return Promise.reject(new Error("Request aborted"));
+    const details = { requestId, targetPeerId, stage: "queued", outcome: "not_executed", executionOutcome: "not_executed" };
+    if (typeof requestId !== "string" || requestId.trim().length === 0 || requestId.length > 128) {
+      return Promise.reject(new RequestFailure("operationId must be a nonempty string of at most 128 characters", "invalid_operation_id", details));
+    }
+    if (signal?.aborted) {
+      return Promise.reject(new RequestFailure(`Request aborted: ${requestId}; queued; not_executed`, "request_aborted", details));
+    }
+    let requestBytes;
+    let fingerprint;
+    try {
+      const target2 = this.getPeerById(targetPeerId);
+      fingerprint = createHash("sha256").update(JSON.stringify({ targetPeerId, endpoint, data })).digest("hex");
+      requestBytes = Buffer.byteLength(JSON.stringify({
+        kind: "request",
+        requestId,
+        peerId: targetPeerId,
+        target: target2?.role,
+        endpoint,
+        data: data ?? null,
+        remainingMs: effectiveTimeoutMs
+      }));
+    } catch {
+      return Promise.reject(new RequestFailure(`Request ${requestId} cannot be serialized; queued; not_executed`, "request_serialization_failed", details));
+    }
+    this.pruneOperations(Date.now());
+    const existing = this.operations.get(requestId);
+    if (existing) {
+      if (existing.fingerprint !== fingerprint) {
+        return Promise.reject(new RequestFailure(`Request ${requestId} already identifies a different operation; existing operation ${existing.status.stage}; not replayed`, "operation_id_collision", { requestId, targetPeerId: existing.status.targetPeerId, stage: existing.status.stage, outcome: "unknown", ...observations(existing.status) }));
+      }
+      const pending = this.pendingRequests.get(requestId);
+      if (pending)
+        return pending.promise;
+      const status = this.getRequestStatus(requestId);
+      if (status.state === "settled" && !status.resultUnavailable) {
+        const error = status.error;
+        if (error && typeof error === "object" && "name" in error && error.name === "RequestFailure" && "code" in error && typeof error.code === "string" && "message" in error && typeof error.message === "string" && "details" in error) {
+          const failureDetails = parseFailureDetails(error.details, { requestId, targetPeerId });
+          if (failureDetails)
+            return Promise.reject(new RequestFailure(error.message, error.code, failureDetails));
+        }
+        return Object.hasOwn(status, "error") ? Promise.reject(status.error) : Promise.resolve(status.response);
+      }
+      return Promise.reject(new RequestFailure(`Request ${requestId} already exists: ${status.state}; ${status.stage}; ${status.outcome}; use get_request_status; not replayed`, "operation_not_replayed", { requestId, targetPeerId, stage: status.stage, outcome: status.executionOutcome === "not_executed" ? "not_executed" : "unknown", ...observations(status) }));
+    }
+    if (requestBytes > MAX_REQUEST_BYTES) {
+      return Promise.reject(new RequestFailure(`Request ${requestId} is ${requestBytes} bytes at server_send; limit ${MAX_REQUEST_BYTES} bytes; queued; not_executed`, "request_too_large", { ...details, bytes: requestBytes, limitBytes: MAX_REQUEST_BYTES, transportStage: "server_send" }));
+    }
+    if (this.pendingRequests.size >= MAX_PENDING_REQUESTS || this.pendingRequestBytes + requestBytes > MAX_PENDING_REQUEST_BYTES) {
+      return Promise.reject(new RequestFailure(`Request ${requestId} rejected at admission: pending capacity exceeded (${this.pendingRequests.size}/${MAX_PENDING_REQUESTS} requests, ${this.pendingRequestBytes + requestBytes}/${MAX_PENDING_REQUEST_BYTES} bytes); queued; not_executed`, "request_capacity_exceeded", { ...details, bytes: this.pendingRequestBytes + requestBytes, limitBytes: MAX_PENDING_REQUEST_BYTES }));
+    }
     const { promise, resolve: resolve5, reject } = Promise.withResolvers();
-    const cancelPending = (reason, error) => {
+    const abortListener = () => {
       const pending = this.pendingRequests.get(requestId);
-      if (!pending || !this.removePendingRequest(pending))
-        return;
-      this.notifyRequestCancelled(pending, reason);
-      pending.reject(error);
+      if (pending)
+        this.endRequestWaiter(pending, "aborted", "Request aborted");
     };
-    const timeoutId = setTimeout(() => cancelPending("timeout", new Error("Request timeout")), effectiveTimeoutMs);
-    const abortListener = () => cancelPending("aborted", new Error("Request aborted"));
+    const timeoutId = setTimeout(() => {
+      const pending = this.pendingRequests.get(requestId);
+      if (pending)
+        this.endRequestWaiter(pending, "timed_out", "Request timeout");
+    }, effectiveTimeoutMs);
+    const now = Date.now();
     const request = {
       id: requestId,
       endpoint,
       data,
       targetPeerId,
-      timestamp: Date.now(),
+      timestamp: now,
       resolve: resolve5,
       reject,
+      promise,
       timeoutId,
       timeoutMs: effectiveTimeoutMs,
+      requestBytes,
       abortSignal: signal,
       abortListener
     };
     this.pendingRequests.set(requestId, request);
+    this.pendingRequestBytes += requestBytes;
+    this.operations.set(requestId, {
+      status: { requestId, targetPeerId, queuedAt: now, stage: "queued", state: "pending", outcome: "pending", executionOutcome: "unknown" },
+      fingerprint,
+      updatedAt: now,
+      resultBytes: 0
+    });
+    this.pruneOperations(now);
     signal?.addEventListener("abort", abortListener, { once: true });
     if (signal?.aborted)
       abortListener();
     const target = this.getPeerById(targetPeerId);
-    if (this.pendingRequests.has(requestId) && target) {
+    if (this.pendingRequests.has(requestId) && target)
       this.notifyRequestAvailable(target.transportPeerId);
-    }
     return promise;
   }
+  endRequestWaiter(request, state, message) {
+    if (!this.removePendingRequest(request))
+      return;
+    const operation = this.operations.get(request.id);
+    const stage = operation?.status.stage ?? (request.lastDeliveryTransportPeerId ? "dispatched" : "queued");
+    const outcome = stage === "queued" || operation?.status.executionOutcome === "not_executed" ? "not_executed" : "unknown";
+    if (operation) {
+      operation.status.state = state;
+      operation.status.outcome = outcome;
+      if (stage === "queued")
+        operation.status.executionOutcome = "not_executed";
+      operation.status.waiterEndedAt = Date.now();
+      operation.updatedAt = Date.now();
+      this.operations.delete(request.id);
+      this.operations.set(request.id, operation);
+    }
+    if (state !== "disconnected") {
+      this.notifyRequestCancelled(request, state === "timed_out" ? "timeout" : "aborted");
+    }
+    const connectionLost = operation?.status.connectionLostAt !== void 0 && operation.status.connectionRestoredAt === void 0;
+    request.reject(new RequestFailure(`${message}: ${request.id}; ${stage}; ${outcome}${connectionLost ? "; connection lost" : ""}; waiter ended, execution is not cancelled or rolled back`, state === "timed_out" ? connectionLost ? "request_connection_lost" : "request_timeout" : `request_${state}`, { requestId: request.id, targetPeerId: request.targetPeerId, stage, outcome, ...operation ? observations(operation.status) : {} }));
+  }
   removePendingRequest(request) {
     if (this.pendingRequests.get(request.id) !== request)
       return false;
@@ -2591,15 +2764,16 @@ var BridgeService = class {
       request.abortSignal.removeEventListener("abort", request.abortListener);
     }
     this.pendingRequests.delete(request.id);
+    this.pendingRequestBytes -= request.requestBytes;
     return true;
   }
   claimNextRequestForTransport(transportPeerId, claimOwner) {
     let outstandingCount = 0;
     for (const request of this.pendingRequests.values()) {
-      if (request.claimOwner === claimOwner)
+      if (request.lastDeliveryTransportPeerId === transportPeerId)
         outstandingCount++;
     }
-    if (outstandingCount >= MAX_OUTSTANDING_REQUESTS_PER_DELIVERY_OWNER)
+    if (outstandingCount >= MAX_OUTSTANDING_REQUESTS_PER_TRANSPORT)
       return null;
     let oldestRequest;
     for (const request of this.pendingRequests.values()) {
@@ -2618,6 +2792,13 @@ var BridgeService = class {
       return null;
     oldestRequest.claimOwner = claimOwner;
     oldestRequest.lastDeliveryTransportPeerId = transportPeerId;
+    const operation = this.operations.get(oldestRequest.id);
+    if (operation) {
+      operation.transportPeerId = transportPeerId;
+      operation.status.stage = "dispatched";
+      operation.status.dispatchedAt = Date.now();
+      operation.updatedAt = Date.now();
+    }
     return {
       requestId: oldestRequest.id,
       peerId: oldestRequest.targetPeerId,
@@ -2640,14 +2821,6 @@ var BridgeService = class {
   }
   releaseDeliveryClaims(claimOwner) {
     const transportPeerIds = /* @__PURE__ */ new Set();
-    for (const request of this.pendingRequests.values()) {
-      if (request.claimOwner !== claimOwner)
-        continue;
-      request.claimOwner = void 0;
-      const peer = this.getPeerById(request.targetPeerId);
-      if (peer)
-        transportPeerIds.add(peer.transportPeerId);
-    }
     for (const cancellation of this.pendingCancellations.values()) {
       if (cancellation.claimOwner !== claimOwner)
         continue;
@@ -2657,38 +2830,169 @@ var BridgeService = class {
     for (const transportPeerId of transportPeerIds)
       this.notifyRequestAvailable(transportPeerId);
   }
+  ownedOperation(transportPeerId, requestId) {
+    this.pruneOperations(Date.now());
+    const operation = this.operations.get(requestId);
+    if (!operation || operation.transportPeerId !== transportPeerId)
+      return void 0;
+    const peer = this.getPeerById(operation.status.targetPeerId);
+    const transport = this.getPeerById(transportPeerId);
+    return peer?.transportPeerId === transportPeerId && transport?.transportPeerId === transportPeerId ? operation : void 0;
+  }
+  observeTransportProgress(transportPeerId, requestId, phase, outcome) {
+    const operation = this.ownedOperation(transportPeerId, requestId);
+    if (!operation || operation.status.state === "settled" || operation.status.stage === "response_delivery" || phase === "executing" && operation.status.stage !== "dispatched")
+      return;
+    const now = Date.now();
+    operation.status.stage = phase;
+    if (phase === "executing")
+      operation.status.executionStartedAt = now;
+    else {
+      operation.status.executionOutcome = outcome ?? "unknown";
+      if (outcome !== "not_executed")
+        operation.status.executionCompletedAt = now;
+    }
+    operation.updatedAt = now;
+    this.operations.delete(requestId);
+    this.operations.set(requestId, operation);
+  }
+  settleTransportResponse(transportPeerId, requestId, response, error, executionOutcome) {
+    const operation = this.ownedOperation(transportPeerId, requestId);
+    if (!operation)
+      return "unknown";
+    if (error !== void 0 && executionOutcome !== void 0) {
+      error = new RequestFailure(typeof error === "string" ? error : "Studio response failed", "studio_response_error", {
+        requestId,
+        targetPeerId: operation.status.targetPeerId,
+        ...observations(operation.status),
+        executionCompletedAt: executionOutcome === "not_executed" ? void 0 : operation.status.executionCompletedAt ?? Date.now(),
+        stage: "response_delivery",
+        outcome: executionOutcome === "not_executed" ? "not_executed" : "unknown",
+        executionOutcome
+      });
+    }
+    return this.recordResponse(requestId, response, error, executionOutcome);
+  }
+  /** Trusted in-process settlement; transport handlers must use settleTransportResponse. */
   resolveRequest(requestId, response) {
-    return this.settleRequest(requestId, (request) => request.resolve(response));
+    return this.recordResponse(requestId, response);
   }
+  /** Trusted in-process settlement; transport handlers must use settleTransportResponse. */
   rejectRequest(requestId, error) {
-    return this.settleRequest(requestId, (request) => request.reject(error));
+    return this.recordResponse(requestId, void 0, error);
   }
-  settleRequest(requestId, settle) {
+  recordResponse(requestId, response, error, executionOutcome) {
     const now = Date.now();
-    this.pruneAcceptedRequestIds(now);
+    this.pruneOperations(now);
+    const operation = this.operations.get(requestId);
+    if (!operation)
+      return "unknown";
+    if (operation.status.state === "settled")
+      return "already_settled";
+    const hasError = error !== void 0;
+    operation.status.state = "settled";
+    const localRejection = error instanceof RequestFailure && error.details.transportStage === "server_send";
+    const responseOutcome = handlerOutcome(response);
+    const completedOutcome = !hasError && responseOutcome === "error" ? "error" : executionOutcome ?? (localRejection ? "not_executed" : hasError ? operation.status.executionOutcome === "success" ? "success" : "error" : responseOutcome);
+    operation.status.executionOutcome = completedOutcome;
+    operation.status.outcome = hasError || completedOutcome === "error" || completedOutcome === "not_executed" ? "error" : "success";
+    if (!localRejection) {
+      operation.status.stage = "response_delivery";
+      if (completedOutcome !== "not_executed")
+        operation.status.executionCompletedAt ??= now;
+    }
+    operation.status.settledAt = now;
+    operation.updatedAt = now;
+    try {
+      const recordedError = error instanceof Error ? { ...error, name: error.name, message: error.message } : error;
+      const serialized = JSON.stringify(hasError ? { error: recordedError } : { response });
+      const bytes = Buffer.byteLength(serialized);
+      if (bytes > MAX_RETAINED_RESULT_BYTES) {
+        operation.status.resultUnavailable = { reason: "size_limit", bytes, limitBytes: MAX_RETAINED_RESULT_BYTES };
+      } else {
+        operation.serializedResult = serialized;
+        operation.resultBytes = bytes;
+        this.retainedResultBytes += bytes;
+        this.retainedResults.set(requestId, operation);
+      }
+    } catch {
+      operation.status.resultUnavailable = { reason: "serialization_failed", limitBytes: MAX_RETAINED_RESULT_BYTES };
+    }
+    this.operations.delete(requestId);
+    this.operations.set(requestId, operation);
     const request = this.pendingRequests.get(requestId);
-    if (!request)
-      return this.acceptedRequestIds.has(requestId) ? "already_settled" : "unknown";
-    const deliveryTransportPeerId = request.lastDeliveryTransportPeerId;
-    this.removePendingRequest(request);
-    this.acceptedRequestIds.set(requestId, now);
-    this.pruneAcceptedRequestIds(now);
-    settle(request);
-    if (deliveryTransportPeerId)
-      this.notifyRequestAvailable(deliveryTransportPeerId);
+    if (request && this.removePendingRequest(request)) {
+      if (hasError)
+        request.reject(error);
+      else
+        request.resolve(response);
+    }
+    this.pendingCancellations.delete(requestId);
+    this.pruneOperations(now);
+    if (operation.transportPeerId)
+      this.notifyRequestAvailable(operation.transportPeerId);
     return "accepted";
   }
-  pruneAcceptedRequestIds(now) {
-    for (const [requestId, acceptedAt] of this.acceptedRequestIds) {
-      if (now - acceptedAt < ACCEPTED_REQUEST_TOMBSTONE_TTL_MS)
+  getRequestStatus(requestId) {
+    this.pruneOperations(Date.now());
+    const operation = this.operations.get(requestId);
+    if (!operation)
+      return void 0;
+    const status = { ...operation.status };
+    if (status.resultUnavailable)
+      status.resultUnavailable = { ...status.resultUnavailable };
+    if (operation.serializedResult !== void 0) {
+      const result = JSON.parse(operation.serializedResult);
+      if (result && typeof result === "object") {
+        if ("response" in result)
+          status.response = result.response;
+        if ("error" in result)
+          status.error = result.error;
+      }
+    }
+    return status;
+  }
+  async getRequestStatusEverywhere(requestId) {
+    return this.getRequestStatus(requestId);
+  }
+  pruneOperations(now) {
+    for (const [requestId, operation] of this.operations) {
+      if (this.pendingRequests.has(requestId))
+        continue;
+      if (now - operation.updatedAt < OPERATION_RETENTION_MS)
+        break;
+      this.operations.delete(requestId);
+      this.retainedResults.delete(requestId);
+      this.retainedResultBytes -= operation.resultBytes;
+    }
+    while (this.operations.size > MAX_OPERATION_RECORDS) {
+      let removed = false;
+      for (const [requestId, operation] of this.operations) {
+        if (this.pendingRequests.has(requestId))
+          continue;
+        this.operations.delete(requestId);
+        this.retainedResults.delete(requestId);
+        this.retainedResultBytes -= operation.resultBytes;
+        removed = true;
+        break;
+      }
+      if (!removed)
         break;
-      this.acceptedRequestIds.delete(requestId);
     }
-    while (this.acceptedRequestIds.size > MAX_ACCEPTED_REQUEST_TOMBSTONES) {
-      const oldestRequestId = this.acceptedRequestIds.keys().next().value;
-      if (oldestRequestId === void 0)
+    if (this.retainedResults.size <= MAX_RETAINED_RESULTS && this.retainedResultBytes <= MAX_RETAINED_RESULT_BYTES)
+      return;
+    for (const [requestId, operation] of this.retainedResults) {
+      operation.status.resultUnavailable = {
+        reason: "retention_capacity",
+        bytes: operation.resultBytes,
+        limitBytes: MAX_RETAINED_RESULT_BYTES
+      };
+      this.retainedResultBytes -= operation.resultBytes;
+      operation.resultBytes = 0;
+      operation.serializedResult = void 0;
+      this.retainedResults.delete(requestId);
+      if (this.retainedResults.size <= MAX_RETAINED_RESULTS && this.retainedResultBytes <= MAX_RETAINED_RESULT_BYTES)
         break;
-      this.acceptedRequestIds.delete(oldestRequestId);
     }
   }
   prunePendingCancellations(now) {
@@ -2707,16 +3011,15 @@ var BridgeService = class {
   cleanupOldRequests() {
     const now = Date.now();
     for (const request of this.pendingRequests.values()) {
-      if (now - request.timestamp > request.timeoutMs && this.removePendingRequest(request)) {
-        this.notifyRequestCancelled(request, "timeout");
-        request.reject(new Error("Request timeout"));
+      if (now - request.timestamp >= request.timeoutMs) {
+        this.endRequestWaiter(request, "timed_out", "Request timeout");
       }
     }
+    this.pruneOperations(now);
   }
   clearAllPendingRequests() {
     for (const request of Array.from(this.pendingRequests.values())) {
-      this.removePendingRequest(request);
-      request.reject(new Error("Connection closed"));
+      this.endRequestWaiter(request, "disconnected", "Connection closed");
     }
     this.pendingCancellations.clear();
   }
@@ -2981,7 +3284,7 @@ Tool descriptions explain selection. Input schemas explain arguments. This guide
 
 - Use selection with action=get when the user's Studio selection should define the scope.
 - Use action=set with instance paths to replace, add to, or remove from the selection. An empty paths array in set mode clears it.
-- Use action=view with a BasePart or Model path to frame it. The current viewing direction is preserved unless from or angleY overrides it. padding below 1 crops closer and above 1 pulls back.
+- Use action=view with a BasePart or Model path to frame it, or omit path to frame exactly one selected BasePart or Model. Empty, multiple, or unsupported selections require an explicit target or a changed selection. The original camera type is restored after framing, including on failure. The current viewing direction is preserved unless from or angleY overrides it. padding below 1 crops closer and above 1 pulls back.
 - For visual proof, change the instance, frame it with selection, then call capture_screenshot.
 
 ## Script changes
@@ -4471,6 +4774,21 @@ async function resolveStudioExeAsync() {
   }
   return candidates[0];
 }
+var WINDOWS_STUDIO_PROCESS_QUERY = [
+  "$ErrorActionPreference = 'Stop'",
+  // Get-Process reports a missing name as an error, not a successful empty set.
+  '$studio = @(); try { $studio = @(Get-Process RobloxStudioBeta -ErrorAction Stop) } catch { if ($_.FullyQualifiedErrorId -notlike "NoProcessFoundForGivenName,*") { throw } }',
+  "$processes = @($studio | ForEach-Object { [PSCustomObject]@{ Id = $_.Id; Name = $_.Name; Path = $_.Path; MainWindowTitle = $_.MainWindowTitle; StartTimeUtcFileTime = $_.StartTime.ToUniversalTime().ToFileTimeUtc().ToString() } })",
+  "ConvertTo-Json -InputObject $processes -Compress"
+].join("; ");
+function parseWindowsStudioProcesses(output) {
+  const parsed = JSON.parse(output);
+  const processes = Array.isArray(parsed) ? parsed : [parsed];
+  if (!processes.every((value) => value !== null && typeof value === "object" && "Id" in value && typeof value.Id === "number" && Number.isSafeInteger(value.Id) && value.Id > 0 && "Name" in value && typeof value.Name === "string" && "Path" in value && typeof value.Path === "string" && "MainWindowTitle" in value && typeof value.MainWindowTitle === "string" && "StartTimeUtcFileTime" in value && typeof value.StartTimeUtcFileTime === "string" && /^[1-9]\d*$/u.test(value.StartTimeUtcFileTime))) {
+    throw new Error("Malformed Roblox Studio process enumeration result.");
+  }
+  return processes;
+}
 async function observeStudioProcesses() {
   const observedAt = Date.now();
   try {
@@ -4493,11 +4811,8 @@ async function observeStudioProcesses() {
     if (process.platform !== "win32" && !isWsl()) {
       return { status: "ok", observedAt, processes: [] };
     }
-    const out = await powershellAsync("Get-Process RobloxStudioBeta -ErrorAction SilentlyContinue | ForEach-Object { [PSCustomObject]@{ Id = $_.Id; Name = $_.Name; Path = $_.Path; MainWindowTitle = $_.MainWindowTitle; StartTimeUtcFileTime = $_.StartTime.ToUniversalTime().ToFileTimeUtc().ToString() } } | ConvertTo-Json -Compress");
-    if (!out)
-      return { status: "ok", observedAt, processes: [] };
-    const parsed = JSON.parse(out);
-    return { status: "ok", observedAt, processes: Array.isArray(parsed) ? parsed : [parsed] };
+    const out = await powershellAsync(WINDOWS_STUDIO_PROCESS_QUERY);
+    return { status: "ok", observedAt, processes: parseWindowsStudioProcesses(out) };
   } catch (error) {
     return {
       status: "error",
@@ -5529,7 +5844,6 @@ var INTERNAL_RESULT_KEYS = /* @__PURE__ */ new Set([
   "transportPeerId",
   "pluginVariant",
   "pluginVersion",
-  "requestId",
   "serverVersion"
 ]);
 var TEXT_RESULT_TOOLS = /* @__PURE__ */ new Set(["get_roblox_docs"]);
@@ -5651,8 +5965,11 @@ function publicToolErrorBody(name, error) {
   }
   if (error instanceof RoutingFailure)
     return publicRoutingError(error);
+  if (error instanceof RequestFailure) {
+    return { error: error.code, message: error.message.slice(0, 500), ...error.details };
+  }
   console.error(`[tool:${name}]`, error);
-  const message = error instanceof Error ? error.message : "Tool execution failed.";
+  const message = error instanceof Error ? error.message : typeof error === "string" ? error : "Tool execution failed.";
   return { error: "tool_failed", message: message.slice(0, 500) };
 }
 function concise(text, maxLength, firstSentence = false) {
@@ -5709,6 +6026,9 @@ function serverInstructions(definitions) {
   if (has("get_connected_instances")) {
     instructions.push("When more than one Studio process scope is connected, call get_connected_instances and pass either a top-level instance id or a multiplayer group's role-suffixed instance id as instance_id.");
   }
+  if (has("get_request_status", "execute_luau", "set_properties")) {
+    instructions.push("Supply a unique operation_id to execute_luau or set_properties when retry safety matters. After a timeout, query get_request_status with that ID before retrying. Identical arguments reuse a retained outcome; changed arguments are rejected. Recovery and deduplication are bounded to the current server session and five-minute retention window; result payloads may be evicted earlier. Unknown status does not mean unexecuted, and cancellation cannot roll back mutations.", "Request stages are queued, dispatched, executing (plugin handler entered), and response_delivery (handler returned or admission rejected). executionOutcome is separate from waiter state and delivery outcome; handler observations do not prove user Luau instructions ran. A waiter timeout is not an execution deadline or rollback. Neither missing progress nor connection loss proves completion.");
+  }
   if (has("search_objects", "get_project_structure", "grep_scripts", "execute_luau")) {
     instructions.push("Use search_objects, get_project_structure, or grep_scripts for standard discovery. Use execute_luau for custom traversal or bulk edits.");
   }
@@ -5771,7 +6091,7 @@ function createToolHttpHandler(options) {
 }
 
 // ../core/dist/auth.js
-import { randomBytes, createHash, timingSafeEqual } from "crypto";
+import { randomBytes, createHash as createHash2, timingSafeEqual } from "crypto";
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync, chmodSync } from "fs";
 import { join as join3, dirname as dirname2 } from "path";
 import { homedir as homedir3 } from "os";
@@ -5809,192 +6129,308 @@ function resolveAuthToken() {
   }
 }
 function tokensMatch(provided, expected) {
-  const a = createHash("sha256").update(provided).digest();
-  const b = createHash("sha256").update(expected).digest();
+  const a = createHash2("sha256").update(provided).digest();
+  const b = createHash2("sha256").update(expected).digest();
   return timingSafeEqual(a, b);
 }
 
+// ../core/dist/http-body-limits.js
+var HTTP_BODY_LIMIT_BYTES = 50 * 1024 * 1024;
+
 // ../core/dist/studio-transport.js
 var HEARTBEAT_INTERVAL_MS = 1e4;
-var MAX_ACTIVE_EVENT_STREAMS = 64;
-var SseStudioTransport = class {
+var MAX_PENDING_ACKS = 128;
+var STUDIO_PROTOCOL_VERSION = 1;
+var MAX_ACTIVE_STUDIO_SOCKETS = 64;
+var MAX_STUDIO_FRAME_BYTES = 64 * 1024 * 1024;
+var MAX_STUDIO_BUFFERED_BYTES = MAX_STUDIO_FRAME_BYTES + 14;
+var WebSocketStudioTransport = class {
   queue;
-  streams = /* @__PURE__ */ new Map();
+  sockets = /* @__PURE__ */ new Map();
+  closing = /* @__PURE__ */ new Set();
   unsubscribeRequestAvailable;
   unsubscribePeerClosed;
   nextGeneration = 0;
+  closed = false;
   constructor(queue) {
     this.queue = queue;
     this.unsubscribeRequestAvailable = queue.onRequestAvailable((transportPeerId) => {
-      const stream = this.streams.get(transportPeerId);
-      if (stream)
-        this.pump(stream);
+      const connection = this.sockets.get(transportPeerId);
+      if (connection)
+        this.pump(connection);
     });
-    this.unsubscribePeerClosed = queue.onPeerClosed((route) => {
-      if (route.peerId === route.transportPeerId) {
-        this.closeTransport(route.transportPeerId);
-      }
+    this.unsubscribePeerClosed = queue.onPeerClosed((peer) => {
+      if (peer.peerId === peer.transportPeerId)
+        this.closeTransport(peer.transportPeerId);
     });
   }
-  get activeStreamCount() {
-    return this.streams.size;
+  get activeSocketCount() {
+    return this.sockets.size;
   }
   canOpen(transportPeerId) {
-    return this.streams.has(transportPeerId) || this.streams.size < MAX_ACTIVE_EVENT_STREAMS;
+    return !this.closed && (this.sockets.has(transportPeerId) || this.sockets.size < MAX_ACTIVE_STUDIO_SOCKETS);
   }
-  open(transportPeerId, sink, status) {
-    if (!this.canOpen(transportPeerId))
+  open(transportPeerId, socket, status) {
+    if (!this.canOpen(transportPeerId) || socket.readyState !== 1)
       return void 0;
     this.nextGeneration += 1;
-    const claimOwner = `sse:${transportPeerId}:${this.nextGeneration}`;
-    const stream = {
+    const claimOwner = `ws:${transportPeerId}:${this.nextGeneration}`;
+    const connection = {
       transportPeerId,
       claimOwner,
-      sink,
+      socket,
       status,
       closed: false,
-      blocked: false,
+      sending: false,
+      pumping: false,
+      settling: false,
       statusPending: true,
-      onClose: () => this.closeStream(stream),
-      onDrain: () => {
-        if (stream.closed)
-          return;
-        stream.blocked = false;
-        this.pump(stream);
-      }
+      heartbeatPending: false,
+      acknowledgements: /* @__PURE__ */ new Map(),
+      onClose: () => {
+        this.closeSocket(connection);
+        this.finishClose(connection);
+      },
+      onError: () => this.closeSocket(connection, 1011, "socket_error"),
+      onMessage: (data, isBinary) => this.receive(connection, data, isBinary)
     };
     this.queue.setDeliveryActive(transportPeerId, claimOwner, true);
-    this.queue.updatePeerActivity(transportPeerId);
-    const replaced = this.streams.get(transportPeerId);
+    const replaced = this.sockets.get(transportPeerId);
     if (replaced)
-      this.closeStream(replaced, true);
-    this.streams.set(transportPeerId, stream);
-    sink.on("close", stream.onClose);
-    sink.on("error", stream.onClose);
-    sink.on("drain", stream.onDrain);
-    stream.heartbeatTimer = setInterval(() => {
-      if (!stream.closed && !stream.blocked) {
-        this.queue.updatePeerActivity(transportPeerId);
-        stream.statusPending = true;
-        this.pump(stream);
-        if (!stream.blocked) {
-          this.write(stream, { kind: "heartbeat", timestamp: Date.now() });
-        }
-      }
+      this.closeSocket(replaced, 1012, "transport_replaced");
+    this.sockets.set(transportPeerId, connection);
+    this.queue.updatePeerActivity(transportPeerId);
+    socket.on("close", connection.onClose);
+    socket.on("error", connection.onError);
+    socket.on("message", connection.onMessage);
+    connection.heartbeatTimer = setInterval(() => {
+      if (!this.isCurrent(connection))
+        return;
+      this.queue.updatePeerActivity(transportPeerId);
+      connection.statusPending = true;
+      connection.heartbeatPending = true;
+      this.pump(connection);
     }, HEARTBEAT_INTERVAL_MS);
-    stream.heartbeatTimer.unref();
-    this.pump(stream);
-    return {
-      transportPeerId,
-      close: () => this.closeStream(stream, true)
-    };
+    connection.heartbeatTimer.unref();
+    this.pump(connection);
+    return { transportPeerId, close: () => this.closeSocket(connection, 1e3, "transport_closed") };
   }
   refreshStatus(transportPeerId) {
     if (transportPeerId !== void 0) {
-      const stream = this.streams.get(transportPeerId);
-      if (stream) {
-        stream.lastStatusJson = void 0;
-        stream.statusPending = true;
-        this.pump(stream);
+      const connection = this.sockets.get(transportPeerId);
+      if (connection) {
+        connection.statusPending = true;
+        this.pump(connection);
       }
       return;
     }
-    for (const stream of this.streams.values()) {
-      stream.lastStatusJson = void 0;
-      stream.statusPending = true;
-      this.pump(stream);
+    for (const connection of this.sockets.values()) {
+      connection.statusPending = true;
+      this.pump(connection);
     }
   }
   closeTransport(transportPeerId) {
-    const stream = this.streams.get(transportPeerId);
-    if (stream)
-      this.closeStream(stream, true);
+    const connection = this.sockets.get(transportPeerId);
+    if (connection)
+      this.closeSocket(connection, 1e3, "peer_unregistered");
   }
   close() {
-    for (const stream of Array.from(this.streams.values())) {
-      this.closeStream(stream, true);
-    }
+    this.closed = true;
+    for (const connection of this.sockets.values())
+      this.closeSocket(connection, 1001, "server_shutdown");
     this.unsubscribeRequestAvailable();
     this.unsubscribePeerClosed();
   }
-  pump(stream) {
-    if (stream.closed || stream.blocked || this.streams.get(stream.transportPeerId) !== stream)
+  isCurrent(connection) {
+    return !connection.closed && this.sockets.get(connection.transportPeerId) === connection;
+  }
+  receive(connection, data, isBinary) {
+    if (!this.isCurrent(connection))
+      return;
+    if (isBinary) {
+      this.closeSocket(connection, 1003, "text_frames_required");
       return;
-    if (stream.statusPending) {
-      stream.statusPending = false;
-      let status;
-      try {
-        status = stream.status();
-      } catch {
-        this.closeStream(stream);
-        return;
-      }
-      const statusJson = JSON.stringify(status);
-      if (statusJson !== stream.lastStatusJson) {
-        stream.lastStatusJson = statusJson;
-        if (!this.write(stream, status))
-          return;
-      }
     }
-    while (!stream.closed && !stream.blocked) {
-      const cancellation = this.queue.claimNextCancellationForTransport(stream.transportPeerId, stream.claimOwner);
-      if (!cancellation)
-        break;
-      if (!this.write(stream, { kind: "cancel", ...cancellation }))
+    const bytes = Array.isArray(data) ? data.reduce((total, chunk) => total + chunk.byteLength, 0) : data.byteLength;
+    if (bytes > MAX_STUDIO_FRAME_BYTES) {
+      this.closeSocket(connection, 1009, `server_receive bytes=${bytes} limit=${MAX_STUDIO_FRAME_BYTES}`);
+      return;
+    }
+    let message;
+    try {
+      const buffer = Array.isArray(data) ? Buffer.concat(data, bytes) : data instanceof ArrayBuffer ? Buffer.from(data) : data;
+      message = JSON.parse(buffer.toString("utf8"));
+    } catch {
+      this.closeSocket(connection, 1007, "invalid_json");
+      return;
+    }
+    if (message === null || typeof message !== "object" || Array.isArray(message) || !("kind" in message) || message.kind !== "response" && message.kind !== "progress" || !("requestId" in message) || typeof message.requestId !== "string" || message.requestId.length === 0 || message.requestId.length > 1024) {
+      this.closeSocket(connection, 1008, "invalid_response");
+      return;
+    }
+    if (message.kind === "progress") {
+      const outcome = "outcome" in message ? message.outcome : void 0;
+      if (!("phase" in message) || message.phase !== "executing" && message.phase !== "response_delivery" || outcome !== void 0 && !isExecutionOutcome(outcome) || message.phase === "executing" && "outcome" in message)
         return;
+      this.queue.observeTransportProgress(connection.transportPeerId, message.requestId, message.phase, outcome);
+      this.queue.updatePeerActivity(connection.transportPeerId);
+      return;
     }
-    while (!stream.closed && !stream.blocked) {
-      const request = this.queue.claimNextRequestForTransport(stream.transportPeerId, stream.claimOwner);
-      if (!request)
+    const executionOutcome = "executionOutcome" in message ? message.executionOutcome : void 0;
+    if (executionOutcome !== void 0 && !isExecutionOutcome(executionOutcome))
+      return;
+    const response = "response" in message ? message.response : void 0;
+    const error = "error" in message ? message.error : void 0;
+    connection.settling = true;
+    try {
+      const disposition = this.queue.settleTransportResponse(connection.transportPeerId, message.requestId, response, error, executionOutcome);
+      if (!this.isCurrent(connection))
         return;
-      const event = {
-        kind: "request",
-        requestId: request.requestId,
-        peerId: request.peerId,
-        target: request.target,
-        endpoint: request.endpoint,
-        data: request.data === void 0 ? null : request.data,
-        remainingMs: request.remainingMs
-      };
-      if (!this.write(stream, event))
+      if (!connection.acknowledgements.has(message.requestId) && connection.acknowledgements.size >= MAX_PENDING_ACKS) {
+        this.closeSocket(connection, 1013, "ack_backpressure");
         return;
+      }
+      connection.acknowledgements.set(message.requestId, {
+        kind: "ack",
+        requestId: message.requestId,
+        disposition
+      });
+      this.queue.updatePeerActivity(connection.transportPeerId);
+    } catch {
+      this.closeSocket(connection, 1011, "response_recording_failed");
+    } finally {
+      connection.settling = false;
     }
+    this.pump(connection);
   }
-  write(stream, event) {
-    if (stream.closed)
-      return false;
+  pump(connection) {
+    if (!this.isCurrent(connection) || connection.sending || connection.pumping || connection.settling)
+      return;
+    connection.pumping = true;
     try {
-      const writable = stream.sink.write(`data: ${JSON.stringify(event)}
-
-`);
-      if (!writable)
-        stream.blocked = true;
-      return writable;
+      while (this.isCurrent(connection) && !connection.sending) {
+        const ack = connection.acknowledgements.values().next().value;
+        if (ack) {
+          connection.acknowledgements.delete(ack.requestId);
+          this.send(connection, ack);
+          continue;
+        }
+        if (connection.statusPending) {
+          connection.statusPending = false;
+          const status = connection.status();
+          const statusJson = JSON.stringify(status);
+          if (statusJson !== connection.lastStatusJson) {
+            connection.lastStatusJson = statusJson;
+            this.send(connection, status, statusJson);
+            continue;
+          }
+        }
+        const cancellation = this.queue.claimNextCancellationForTransport(connection.transportPeerId, connection.claimOwner);
+        if (cancellation) {
+          this.send(connection, { kind: "cancel", ...cancellation });
+          continue;
+        }
+        const request = this.queue.claimNextRequestForTransport(connection.transportPeerId, connection.claimOwner);
+        if (request) {
+          this.send(connection, { kind: "request", ...request, data: request.data ?? null });
+          continue;
+        }
+        if (connection.heartbeatPending) {
+          connection.heartbeatPending = false;
+          this.send(connection, { kind: "heartbeat", timestamp: Date.now() });
+          continue;
+        }
+        return;
+      }
     } catch {
-      this.closeStream(stream);
-      return false;
+      this.closeSocket(connection, 1011, "transport_pump_failed");
+    } finally {
+      connection.pumping = false;
     }
   }
-  closeStream(stream, endSink = false) {
-    if (stream.closed)
+  send(connection, event, serialized) {
+    let json;
+    try {
+      json = serialized ?? JSON.stringify(event);
+    } catch {
+      if (event.kind !== "request")
+        throw new Error("Unserializable Studio event");
+      this.queue.settleTransportResponse(connection.transportPeerId, event.requestId, void 0, new RequestFailure("Studio request could not be serialized before WebSocket delivery at server_send", "studio_frame_serialization_failed", {
+        requestId: event.requestId,
+        targetPeerId: event.peerId,
+        stage: "dispatched",
+        outcome: "not_executed",
+        executionOutcome: "not_executed",
+        transportStage: "server_send"
+      }));
       return;
-    stream.closed = true;
-    clearInterval(stream.heartbeatTimer);
-    stream.sink.removeListener("close", stream.onClose);
-    stream.sink.removeListener("error", stream.onClose);
-    stream.sink.removeListener("drain", stream.onDrain);
-    if (this.streams.get(stream.transportPeerId) === stream) {
-      this.streams.delete(stream.transportPeerId);
-    }
-    this.queue.updatePeerActivity(stream.transportPeerId);
-    this.queue.setDeliveryActive(stream.transportPeerId, stream.claimOwner, false);
-    this.queue.releaseDeliveryClaims(stream.claimOwner);
-    if (endSink) {
-      try {
-        stream.sink.end();
-      } catch {
+    }
+    const bytes = Buffer.byteLength(json);
+    if (bytes > MAX_STUDIO_FRAME_BYTES) {
+      if (event.kind === "request") {
+        this.queue.settleTransportResponse(connection.transportPeerId, event.requestId, void 0, new RequestFailure(`Studio request frame is ${bytes} bytes; limit is ${MAX_STUDIO_FRAME_BYTES} at server_send`, "studio_frame_too_large", {
+          requestId: event.requestId,
+          targetPeerId: event.peerId,
+          stage: "dispatched",
+          outcome: "not_executed",
+          executionOutcome: "not_executed",
+          transportStage: "server_send",
+          bytes,
+          limitBytes: MAX_STUDIO_FRAME_BYTES
+        }));
+      } else {
+        this.closeSocket(connection, 1009, `server_send bytes=${bytes} limit=${MAX_STUDIO_FRAME_BYTES}`);
       }
+      return;
     }
+    if (connection.socket.readyState !== 1 || connection.socket.bufferedAmount + bytes > MAX_STUDIO_BUFFERED_BYTES) {
+      this.closeSocket(connection, 1013, "server_send_backpressure");
+      return;
+    }
+    connection.sending = true;
+    connection.socket.send(json, (error) => {
+      if (!this.isCurrent(connection))
+        return;
+      connection.sending = false;
+      if (error)
+        this.closeSocket(connection, 1011, "server_send_failed");
+      else
+        this.pump(connection);
+    });
+  }
+  closeSocket(connection, code, reason) {
+    if (connection.closed)
+      return;
+    connection.closed = true;
+    clearInterval(connection.heartbeatTimer);
+    connection.socket.removeListener("message", connection.onMessage);
+    connection.acknowledgements.clear();
+    if (this.sockets.get(connection.transportPeerId) === connection)
+      this.sockets.delete(connection.transportPeerId);
+    this.queue.setDeliveryActive(connection.transportPeerId, connection.claimOwner, false);
+    this.queue.releaseDeliveryClaims(connection.claimOwner);
+    if (code !== void 0) {
+      this.closing.add(connection);
+      connection.closeTimer = setTimeout(() => {
+        connection.socket.terminate();
+        this.finishClose(connection);
+      }, 1e3);
+      connection.closeTimer.unref();
+      connection.socket.close(code, reason);
+      if (this.closing.size > MAX_ACTIVE_STUDIO_SOCKETS) {
+        const oldest = this.closing.values().next().value;
+        if (oldest) {
+          oldest.socket.terminate();
+          this.finishClose(oldest);
+        }
+      }
+    }
+  }
+  finishClose(connection) {
+    clearTimeout(connection.closeTimer);
+    this.closing.delete(connection);
+    connection.socket.removeListener("close", connection.onClose);
+    connection.socket.removeListener("error", connection.onError);
   }
 };
 
@@ -6074,13 +6510,14 @@ function requiredClosedLineRange(body, toolName) {
   return { startLine: parsed.startLine, endLine: parsed.endLine };
 }
 var TOOL_HANDLERS = {
+  get_request_status: (tools, body) => tools.getRequestStatus(body.request_id),
   get_roblox_skills: (tools, body) => tools.getRobloxSkills(body.action, body.name),
   get_roblox_docs: (tools, body) => tools.getRobloxDocs(body.name, body.doc_type, body.section),
   get_place_info: (tools, body) => tools.getPlaceInfo(body.instance_id),
   search_objects: (tools, body) => tools.searchObjects(body.query, body.searchType, body.propertyName, body.instance_id),
   get_instance_properties: (tools, body) => tools.getInstanceProperties(body.instancePath, body.excludeSource, body.instance_id),
   get_project_structure: (tools, body) => tools.getProjectStructure(body.path, body.maxDepth, body.scriptsOnly, body.instance_id),
-  set_properties: (tools, body) => tools.setProperties(body.instancePath, body.properties, body.instance_id),
+  set_properties: (tools, body) => tools.setProperties(body.instancePath, body.properties, body.instance_id, body.operation_id),
   grep_scripts: (tools, body, context) => tools.grepScripts(body.pattern, {
     caseSensitive: body.caseSensitive,
     usePattern: body.usePattern,
@@ -6104,7 +6541,7 @@ var TOOL_HANDLERS = {
   },
   get_attributes: (tools, body) => tools.getAttributes(body.instancePath, body.instance_id),
   selection: (tools, body) => tools.selection(body.action, body, body.instance_id),
-  execute_luau: (tools, body) => tools.executeLuau(body.code, body.target, body.instance_id),
+  execute_luau: (tools, body) => tools.executeLuau(body.code, body.target, body.instance_id, body.operation_id),
   eval_server_runtime: (tools, body) => tools.evalServerRuntime(body.code, body.instance_id),
   eval_client_runtime: (tools, body) => tools.evalClientRuntime(body.code, body.target, body.instance_id),
   set_network_profile: (tools, body) => tools.setNetworkProfile(body.profile, body.target, body.overrides, body.instance_id),
@@ -6116,7 +6553,7 @@ var TOOL_HANDLERS = {
   manage_instance: (tools, body) => tools.manageInstance(body),
   solo_playtest: (tools, body) => tools.soloPlaytest(body.action, body.mode, body.timeout, body.instance_id),
   multiplayer_playtest: (tools, body) => tools.multiplayerPlaytest(body.action, body.numPlayers, body.target, body.testArgs, body.value, body.timeout, body.instance_id),
-  get_runtime_logs: (tools, body) => tools.getRuntimeLogs(body.instance_id, body.multiplayer_group_id, body.cursor, body.cursor_by_instance, body.tail, body.filter),
+  get_runtime_logs: (tools, body, context) => tools.getRuntimeLogs(body.instance_id, body.multiplayer_group_id, body.cursor, body.cursor_by_instance, body.tail, body.filter, context?.signal),
   capture_script_profiler: (tools, body) => tools.captureScriptProfiler(body.target, {
     duration_ms: body.duration_ms,
     frequency: body.frequency,
@@ -6172,6 +6609,16 @@ var TOOL_HANDLERS = {
     maxReplacements: body.maxReplacements
   }, body.instance_id)
 };
+var MAX_STUDIO_SESSIONS = 256;
+function rejectStudioUpgrade(socket, status, error) {
+  const body = JSON.stringify({ error });
+  socket.end(`HTTP/1.1 ${status} ${http.STATUS_CODES[status]}\r
+Connection: close\r
+Content-Type: application/json\r
+Content-Length: ${Buffer.byteLength(body)}\r
+\r
+${body}`);
+}
 function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
   const app = express();
   const studioLifecycleCallable = !allowedTools || allowedTools.has("manage_instance");
@@ -6181,8 +6628,19 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
   let mcpServerStartTime = 0;
   const proxyInstances = /* @__PURE__ */ new Set();
   const rejectedVersionPeers = /* @__PURE__ */ new Set();
-  const eventTransport = new SseStudioTransport(bridge);
-  const eventStreamHandles = /* @__PURE__ */ new Set();
+  const studioTransport = new WebSocketStudioTransport(bridge);
+  const transportTokens = /* @__PURE__ */ new Map();
+  const boundServers = /* @__PURE__ */ new Set();
+  const webSocketServer = new WebSocketServer({
+    noServer: true,
+    clientTracking: false,
+    perMessageDeflate: false,
+    maxPayload: MAX_STUDIO_FRAME_BYTES
+  });
+  let closed = false;
+  const unsubscribePeerClosed = bridge.onPeerClosed((peer) => {
+    transportTokens.delete(peer.peerId);
+  });
   const setMCPServerActive = (active) => {
     mcpServerActive = active;
     if (active) {
@@ -6192,14 +6650,14 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
       mcpServerStartTime = 0;
       lastMCPActivity = 0;
     }
-    eventTransport.refreshStatus();
+    studioTransport.refreshStatus();
   };
   const trackMCPActivity = () => {
     if (mcpServerActive) {
       const wasConnected = Date.now() - lastMCPActivity < 3e4;
       lastMCPActivity = Date.now();
       if (!wasConnected)
-        eventTransport.refreshStatus();
+        studioTransport.refreshStatus();
     }
   };
   const isMCPServerActive = () => {
@@ -6223,6 +6681,67 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
     return bridge.getPeers().length > 0;
   };
   const allowedOrigins = new Set(security?.allowedOrigins ?? []);
+  const upgradeStudio = (req, socket, head) => {
+    socket.on("error", () => socket.destroy());
+    if (closed) {
+      rejectStudioUpgrade(socket, 503, "server_shutdown");
+      return;
+    }
+    let url;
+    try {
+      url = new URL(req.url ?? "/", "http://localhost");
+    } catch {
+      rejectStudioUpgrade(socket, 400, "invalid_websocket_url");
+      return;
+    }
+    if (url.pathname !== "/studio") {
+      rejectStudioUpgrade(socket, 404, "unknown_websocket_endpoint");
+      return;
+    }
+    const origin = req.headers.origin;
+    if (origin && !allowedOrigins.has(origin)) {
+      rejectStudioUpgrade(socket, 403, "forbidden_origin");
+      return;
+    }
+    if (req.method !== "GET" || url.searchParams.getAll("protocolVersion").length !== 1 || url.searchParams.get("protocolVersion") !== String(STUDIO_PROTOCOL_VERSION)) {
+      rejectStudioUpgrade(socket, 426, "studio_protocol_mismatch");
+      return;
+    }
+    const peerId = url.searchParams.get("peerId");
+    if (!peerId || url.searchParams.getAll("peerId").length !== 1) {
+      rejectStudioUpgrade(socket, 400, "missing_peer_id");
+      return;
+    }
+    const peer = bridge.getPeerById(peerId);
+    if (!peer) {
+      rejectStudioUpgrade(socket, 404, "unknown_peer");
+      return;
+    }
+    if (peer.transportPeerId !== peerId) {
+      rejectStudioUpgrade(socket, 403, "peer_has_no_socket");
+      return;
+    }
+    const token = transportTokens.get(peerId);
+    const provided = req.headers["x-studio-token"];
+    if (!token || typeof provided !== "string" || !tokensMatch(provided, token)) {
+      rejectStudioUpgrade(socket, 401, "invalid_studio_token");
+      return;
+    }
+    if (!studioTransport.canOpen(peerId)) {
+      rejectStudioUpgrade(socket, 503, "studio_socket_capacity_reached");
+      return;
+    }
+    webSocketServer.handleUpgrade(req, socket, head, (webSocket) => {
+      webSocket.on("error", (error) => {
+        if ("code" in error && error.code === "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH") {
+          console.error(`[studio-websocket] server_receive frame exceeds limitBytes=${MAX_STUDIO_FRAME_BYTES}`);
+        }
+      });
+      const handle = studioTransport.open(peerId, webSocket, () => eventStatus(peerId));
+      if (!handle)
+        webSocket.close(1013, "studio_socket_capacity_reached");
+    });
+  };
   app.use((req, res, next) => {
     const origin = req.headers.origin;
     if (typeof origin !== "string" || origin === "") {
@@ -6247,7 +6766,10 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
     next();
   });
   const authToken = security?.authToken;
-  const authRequired = (path6) => path6 === "/mcp" || path6.startsWith("/mcp/") || path6 === "/proxy" || path6 === "/topology" || path6 === "/unregister-instance-id" || path6 === "/create-multiplayer-group" || path6 === "/remove-multiplayer-group";
+  const authRequired = (requestPath) => {
+    const path6 = requestPath.toLowerCase().replace(/\/+$/, "");
+    return path6 === "/mcp" || path6.startsWith("/mcp/") || path6 === "/proxy" || path6 === "/topology" || path6 === "/request-status" || path6 === "/unregister-instance-id" || path6 === "/create-multiplayer-group" || path6 === "/remove-multiplayer-group";
+  };
   app.use((req, res, next) => {
     if (!authToken || !authRequired(req.path)) {
       next();
@@ -6265,8 +6787,31 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
       message: 'Missing or invalid auth token. Send it as "X-MCP-Auth: <token>" or "Authorization: Bearer <token>". ' + (security?.authTokenHint ?? "The token is in ~/.robloxstudio-mcp/auth-token (or ROBLOX_STUDIO_AUTH_TOKEN).")
     });
   });
-  app.use(express.json({ limit: "50mb" }));
-  app.use(express.urlencoded({ limit: "50mb", extended: true }));
+  app.use(express.json({ limit: HTTP_BODY_LIMIT_BYTES }));
+  app.use(express.urlencoded({ limit: HTTP_BODY_LIMIT_BYTES, extended: true }));
+  const handleBodySizeError = (error, _req, res, next) => {
+    if (!error || typeof error !== "object" || !("type" in error) || error.type !== "entity.too.large") {
+      next(error);
+      return;
+    }
+    const bytes = "received" in error && typeof error.received === "number" ? error.received : "length" in error && typeof error.length === "number" ? error.length : void 0;
+    if (bytes === void 0) {
+      next(error);
+      return;
+    }
+    res.status(413).json({
+      error: `HTTP request body is ${bytes} bytes at http_receive; limit ${HTTP_BODY_LIMIT_BYTES} bytes; queued; not_executed`,
+      code: "request_too_large",
+      details: {
+        bytes,
+        limitBytes: HTTP_BODY_LIMIT_BYTES,
+        stage: "queued",
+        outcome: "not_executed",
+        transportStage: "http_receive"
+      }
+    });
+  };
+  app.use(handleBodySizeError);
   app.get("/health", (req, res) => {
     const peers = bridge.getPublicPeers().map(toPassivePeer);
     const instances = bridge.getPublicInstances().map(toPassiveInstance);
@@ -6296,7 +6841,8 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
       uptime: mcpServerActive ? Date.now() - mcpServerStartTime : 0,
       pendingRequests: bridge.getPendingRequestCount(),
       proxyInstanceCount: proxyInstances.size,
-      activeEventStreams: eventTransport.activeStreamCount,
+      activeWebSockets: studioTransport.activeSocketCount,
+      studioSocketCapacity: MAX_ACTIVE_STUDIO_SOCKETS,
       streamableHttp: !!serverConfig
     });
   });
@@ -6401,6 +6947,10 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
         return;
       }
     }
+    if (closed || !isProxiedPeer && !transportTokens.has(peerId) && transportTokens.size >= MAX_STUDIO_SESSIONS) {
+      res.status(503).json({ success: false, error: closed ? "server_shutdown" : "studio_session_capacity_reached" });
+      return;
+    }
     let result;
     try {
       result = bridge.registerPeer({
@@ -6437,14 +6987,20 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
       });
       return;
     }
-    eventTransport.refreshStatus(transportPeerId);
+    let transportToken;
+    if (!isProxiedPeer) {
+      transportToken = transportTokens.get(peerId) ?? randomBytes2(32).toString("hex");
+      transportTokens.set(peerId, transportToken);
+    }
+    studioTransport.refreshStatus(transportPeerId);
     res.json({
       success: true,
       assignedRole: result.assignedRole,
       peerId: result.peerId,
       instanceId: result.instanceId,
       multiplayerGroupId: result.multiplayerGroupId,
-      serverVersion
+      serverVersion,
+      ...!isProxiedPeer ? { protocolVersion: STUDIO_PROTOCOL_VERSION, transportToken } : {}
     });
   });
   app.post("/disconnect", (req, res) => {
@@ -6504,71 +7060,24 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
       serverVersion: serverConfig?.version
     });
   });
-  app.get("/events", (req, res) => {
-    const peerId = typeof req.query.peerId === "string" ? req.query.peerId : void 0;
-    if (!peerId) {
-      res.status(400).json({
-        error: "missing_peer_id",
-        message: "peerId is required"
-      });
-      return;
-    }
-    const peer = bridge.getPeerById(peerId);
-    if (!peer) {
-      res.status(404).json({
-        error: "unknown_peer",
-        knownPeer: false
-      });
-      return;
-    }
-    if (peer.transportPeerId !== peerId) {
-      res.status(409).json({
-        error: "peer_has_no_event_stream",
-        transportPeerId: peer.transportPeerId
-      });
-      return;
-    }
-    if (!eventTransport.canOpen(peerId)) {
-      res.setHeader("Retry-After", "1");
-      res.status(503).json({
-        error: "event_stream_capacity_reached",
-        capacity: MAX_ACTIVE_EVENT_STREAMS
-      });
-      return;
-    }
-    bridge.updatePeerActivity(peerId);
-    res.status(200);
-    res.setHeader("Content-Type", "text/event-stream; charset=utf-8");
-    res.setHeader("Cache-Control", "no-cache, no-transform");
-    res.setHeader("Connection", "keep-alive");
-    res.setHeader("X-Accel-Buffering", "no");
-    res.flushHeaders();
-    const handle = eventTransport.open(peerId, res, () => eventStatus(peerId));
-    if (!handle) {
-      res.end();
-      return;
-    }
-    eventStreamHandles.add(handle);
-    res.once("close", () => eventStreamHandles.delete(handle));
+  app.get(["/studio", "/events"], (_req, res) => {
+    res.setHeader("Upgrade", "websocket");
+    res.status(426).json({ error: "studio_websocket_required", protocolVersion: STUDIO_PROTOCOL_VERSION });
   });
-  app.post("/response", (req, res) => {
-    const { requestId, response, error } = req.body;
-    if (typeof requestId !== "string" || requestId.length === 0) {
-      res.status(400).json({
-        success: false,
-        error: "invalid_request_id"
-      });
-      return;
-    }
-    const disposition = error !== void 0 ? bridge.rejectRequest(requestId, error) : bridge.resolveRequest(requestId, response);
-    if (disposition === "unknown") {
-      res.status(404).json({ success: false, disposition });
+  app.post("/response", (_req, res) => {
+    res.setHeader("Upgrade", "websocket");
+    res.status(426).json({ error: "studio_websocket_required", protocolVersion: STUDIO_PROTOCOL_VERSION });
+  });
+  app.get("/request-status", (req, res) => {
+    const requestId = req.query.requestId;
+    if (typeof requestId !== "string" || requestId.length === 0 || requestId.length > 1024) {
+      res.status(400).json({ error: "invalid_request_id" });
       return;
     }
-    res.json({ success: true, disposition });
+    res.json({ status: bridge.getRequestStatus(requestId) ?? null });
   });
   app.post("/proxy", async (req, res) => {
-    const { endpoint, data, targetPeerId, proxyInstanceId, timeoutMs } = req.body;
+    const { endpoint, data, targetPeerId, proxyInstanceId, timeoutMs, operationId } = req.body;
     if (!endpoint || !targetPeerId) {
       res.status(400).json({ error: "endpoint and targetPeerId are required" });
       return;
@@ -6580,17 +7089,22 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
     if (proxyInstanceId) {
       proxyInstances.add(proxyInstanceId);
     }
+    if (operationId !== void 0 && (typeof operationId !== "string" || operationId.trim().length === 0 || operationId.length > 128)) {
+      res.status(400).json({ error: "operationId must be a non-empty string of at most 128 characters" });
+      return;
+    }
     const controller = new AbortController();
     const abort = () => controller.abort();
     req.once("aborted", abort);
     res.once("close", abort);
     try {
-      const response = await bridge.sendRequest(endpoint, data, targetPeerId, timeoutMs, controller.signal);
+      const response = await bridge.sendRequest(endpoint, data, targetPeerId, timeoutMs, controller.signal, operationId);
       res.json({ response });
     } catch (error) {
       if (!res.headersSent && !res.destroyed) {
         res.status(500).json({
-          error: error instanceof Error ? error.message : "Proxy request failed"
+          error: error instanceof Error ? error.message : error === void 0 ? "Proxy request failed" : error,
+          ...error instanceof RequestFailure ? { code: error.code, details: error.details } : {}
         });
       }
     } finally {
@@ -6642,11 +7156,29 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
   app.isMCPServerActive = isMCPServerActive;
   app.trackMCPActivity = trackMCPActivity;
   app.closeMcpHandler = () => mcpHandler?.close();
+  app.attachStudioTransport = (server) => {
+    if (closed)
+      throw new Error("Cannot attach a closed Studio transport");
+    if (boundServers.has(server))
+      return;
+    boundServers.add(server);
+    server.on("upgrade", upgradeStudio);
+    server.once("close", () => {
+      boundServers.delete(server);
+      server.removeListener("upgrade", upgradeStudio);
+    });
+  };
   app.cleanup = async () => {
-    for (const handle of eventStreamHandles)
-      handle.close();
-    eventStreamHandles.clear();
-    eventTransport.close();
+    if (closed)
+      return;
+    closed = true;
+    for (const server of boundServers)
+      server.removeListener("upgrade", upgradeStudio);
+    boundServers.clear();
+    unsubscribePeerClosed();
+    transportTokens.clear();
+    studioTransport.close();
+    webSocketServer.close();
     await mcpHandler?.close();
   };
   return app;
@@ -6668,18 +7200,26 @@ async function listenWithRetry(app, host, startPort, maxAttempts = 5) {
   throw new Error(`All ports ${startPort}-${startPort + maxAttempts - 1} are in use. Stop some MCP server instances and retry.`);
 }
 function bindPort(app, host, port) {
-  return new Promise((resolve5, reject) => {
-    const server = http.createServer(app);
-    const onError = (err2) => {
-      server.removeListener("error", onError);
-      reject(err2);
-    };
-    server.once("error", onError);
-    server.listen(port, host, () => {
-      server.removeListener("error", onError);
+  const { promise, resolve: resolve5, reject } = Promise.withResolvers();
+  const server = http.createServer(app);
+  const onError = (err2) => {
+    server.removeListener("error", onError);
+    reject(err2);
+  };
+  server.once("error", onError);
+  server.listen(port, host, () => {
+    server.removeListener("error", onError);
+    try {
+      if ("attachStudioTransport" in app && typeof app.attachStudioTransport === "function") {
+        app.attachStudioTransport(server);
+      }
       resolve5(server);
-    });
+    } catch (error) {
+      server.close();
+      reject(error);
+    }
   });
+  return promise;
 }
 
 // ../core/dist/tools/studio-client.js
@@ -6688,15 +7228,8 @@ var StudioHttpClient = class {
   constructor(bridge) {
     this.bridge = bridge;
   }
-  async request(endpoint, data, targetPeerId, timeoutMs, signal) {
-    try {
-      return await this.bridge.sendRequest(endpoint, data, targetPeerId, timeoutMs, signal);
-    } catch (error) {
-      if (error instanceof Error && error.message === "Request timeout") {
-        throw new Error("Studio plugin connection timeout. Make sure the Roblox Studio plugin is running and activated.");
-      }
-      throw error;
-    }
+  async request(endpoint, data, targetPeerId, timeoutMs, signal, operationId) {
+    return this.bridge.sendRequest(endpoint, data, targetPeerId, timeoutMs, signal, operationId);
   }
 };
 
@@ -7521,7 +8054,7 @@ function decodeImagePathToRgba(imagePath) {
 }
 
 // ../core/dist/studio-skills.js
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
 import * as path4 from "path";
 
@@ -8406,7 +8939,7 @@ function parseBuiltInStudioSkills(buffer) {
       hasCombinedDocument: group.combined !== void 0,
       content: selected.content,
       contentLength: Buffer.byteLength(selected.content, "utf8"),
-      contentSha256: createHash2("sha256").update(selected.content).digest("hex")
+      contentSha256: createHash3("sha256").update(selected.content).digest("hex")
     };
   }).sort((left, right) => left.name.localeCompare(right.name));
 }
@@ -8473,7 +9006,7 @@ function loadBuiltInStudioSkills(bundlePath = resolveAssistantBundlePath()) {
   const value = {
     bundlePath,
     bundleModifiedAt: stats.mtime.toISOString(),
-    bundleSha256: createHash2("sha256").update(buffer).digest("hex"),
+    bundleSha256: createHash3("sha256").update(buffer).digest("hex"),
     studioVersion,
     skills
   };
@@ -9506,6 +10039,7 @@ var MAX_DEVICE_MATRIX_ENTRIES = 6;
 var MAX_NETWORK_PACKET_LOSS_PERCENT = 0.5;
 var GREP_SCRIPTS_TIMEOUT_MS = 12e4;
 var MAX_GREP_PATTERN_UTF8_BYTES = 4096;
+var RUNTIME_LOG_PEER_TIMEOUT_MS = 5e3;
 var STUDIO_ASSISTANT_SOURCE_IMAGE_LABEL = "Studio Assistant Source Image";
 var CREATOR_STORE_SEARCH_TYPES = /* @__PURE__ */ new Set([
   "Audio",
@@ -10343,8 +10877,8 @@ var RobloxStudioTools = class {
   _peerForRoleInScope(instanceId, role) {
     return this.bridge.getPeersInScope(instanceId).find((peer) => peer.role === role);
   }
-  _requestPeer(endpoint, data, targetPeerId, timeoutMs, signal) {
-    return this.client.request(endpoint, data, targetPeerId, timeoutMs, signal);
+  _requestPeer(endpoint, data, targetPeerId, timeoutMs, signal, operationId) {
+    return this.client.request(endpoint, data, targetPeerId, timeoutMs, signal, operationId);
   }
   _request(endpoint, data, instanceId, role, timeoutMs, signal) {
     const peer = this._peerForRoleInScope(instanceId, role);
@@ -10358,7 +10892,7 @@ var RobloxStudioTools = class {
     return this._requestPeer(endpoint, data, peer.peerId, timeoutMs, signal);
   }
   // Resolve an optional Studio process plus role to one exact Peer and dispatch.
-  async _callSingle(endpoint, data, target, instance_id, timeoutMs, signal) {
+  async _callSingle(endpoint, data, target, instance_id, timeoutMs, signal, operationId) {
     const resolved = this.bridge.resolveTarget({ instance_id, target });
     if (!resolved.ok)
       throw new RoutingFailure(resolved.error);
@@ -10369,7 +10903,7 @@ var RobloxStudioTools = class {
         data: this._routingErrorData()
       });
     }
-    return this._requestPeer(endpoint, data, resolved.targetPeerId, timeoutMs, signal);
+    return this._requestPeer(endpoint, data, resolved.targetPeerId, timeoutMs, signal, operationId);
   }
   // Prefer the first client role in the selected process/group scope for live
   // viewport and input operations; otherwise retain the default Peer's Instance.
@@ -10768,11 +11302,11 @@ var RobloxStudioTools = class {
       ]
     };
   }
-  async setProperties(instancePath, properties, instance_id) {
+  async setProperties(instancePath, properties, instance_id, operation_id) {
     if (!instancePath || !properties) {
       throw new Error("instancePath and properties are required for set_properties");
     }
-    const response = await this._callSingle("/api/set-properties", { instancePath, properties }, void 0, instance_id);
+    const response = await this._callSingle("/api/set-properties", { instancePath, properties }, void 0, instance_id, void 0, void 0, operation_id);
     return { content: [{ type: "text", text: JSON.stringify(response) }] };
   }
   async getScriptSource(instancePath, startLine, endLine, instance_id) {
@@ -10902,9 +11436,6 @@ var RobloxStudioTools = class {
       }
       return this.setSelection(opts.paths, opts.mode, instance_id);
     }
-    if (!opts.path) {
-      throw new Error("selection action=view requires path");
-    }
     return this.focusViewport(opts.path, opts.from, opts.padding, opts.angleY, instance_id);
   }
   async getSelection(instance_id) {
@@ -10937,8 +11468,8 @@ var RobloxStudioTools = class {
     };
   }
   async focusViewport(instancePath, from, padding, angleY, instance_id) {
-    if (!instancePath) {
-      throw new Error("selection action=view requires path");
+    if (instancePath !== void 0 && (typeof instancePath !== "string" || instancePath.length === 0)) {
+      throw new Error("selection path must be a non-empty instance path when provided");
     }
     if (padding !== void 0 && (padding <= 0 || padding > 10)) {
       throw new Error("selection padding must be greater than 0 and at most 10");
@@ -10962,11 +11493,11 @@ var RobloxStudioTools = class {
       ]
     };
   }
-  async executeLuau(code, target, instance_id) {
+  async executeLuau(code, target, instance_id, operation_id) {
     if (!code) {
       throw new Error("Code is required for execute_luau");
     }
-    const response = await this._callSingle("/api/execute-luau", { code }, target || "edit", instance_id);
+    const response = await this._callSingle("/api/execute-luau", { code }, target || "edit", instance_id, void 0, void 0, operation_id);
     return {
       content: [
         {
@@ -11367,7 +11898,7 @@ var RobloxStudioTools = class {
       ]
     };
   }
-  async getRuntimeLogs(instance_id, multiplayer_group_id, cursor, cursor_by_instance, tail, filter) {
+  async getRuntimeLogs(instance_id, multiplayer_group_id, cursor, cursor_by_instance, tail, filter, signal) {
     if (instance_id !== void 0 && multiplayer_group_id !== void 0) {
       throw new Error("get_runtime_logs accepts only one of instance_id or multiplayer_group_id.");
     }
@@ -11511,7 +12042,7 @@ var RobloxStudioTools = class {
         if (filter !== void 0)
           data.filter = filter;
         try {
-          const responseValue = await this.client.request("/api/get-runtime-logs", data, peer.peerId);
+          const responseValue = await this.client.request("/api/get-runtime-logs", data, peer.peerId, RUNTIME_LOG_PEER_TIMEOUT_MS, signal);
           if (typeof responseValue !== "object" || responseValue === null || Array.isArray(responseValue)) {
             return {
               peerId: peer.peerId,
@@ -11538,6 +12069,8 @@ var RobloxStudioTools = class {
             nextSince: response.nextSince
           };
         } catch (error) {
+          if (signal?.aborted)
+            throw error;
           return { peerId: peer.peerId, role: peer.role, error: errorMessage(error) };
         }
       }));
@@ -12593,6 +13126,20 @@ var RobloxStudioTools = class {
       multiplayerGroups: this.bridge.getConnectedMultiplayerGroups()
     });
   }
+  async getRequestStatus(request_id) {
+    if (typeof request_id !== "string" || request_id.length === 0 || request_id.length > 128) {
+      throw new Error("request_id must contain between 1 and 128 characters");
+    }
+    const status = await this.bridge.getRequestStatusEverywhere(request_id);
+    if (status)
+      return this._textResult({ ...status });
+    return this._textResult({
+      requestId: request_id,
+      state: "unknown",
+      outcome: "unknown",
+      message: "No retained operation record. It may have expired, been evicted, or belonged to an earlier server session. Do not infer that the mutation was not executed."
+    });
+  }
   // === Asset Tools ===
   async searchAssets(assetType, query, maxResults, sortBy, robloxCreatedOnly) {
     const normalized = normalizeCreatorStoreSearch(assetType, query);
@@ -13435,6 +13982,42 @@ var RobloxStudioTools = class {
 // ../core/dist/proxy-bridge-service.js
 import { randomUUID as randomUUID4 } from "crypto";
 var PROXY_RESPONSE_GRACE_MS = 5e3;
+function parseRequestStatus(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("Proxy returned an invalid request status");
+  if (!("requestId" in value) || typeof value.requestId !== "string" || !("targetPeerId" in value) || typeof value.targetPeerId !== "string" || !("queuedAt" in value) || typeof value.queuedAt !== "number" || !("stage" in value) || !isRequestStage(value.stage) || !("state" in value) || value.state !== "pending" && value.state !== "timed_out" && value.state !== "aborted" && value.state !== "disconnected" && value.state !== "settled" || !("outcome" in value) || value.outcome !== "pending" && value.outcome !== "not_executed" && value.outcome !== "unknown" && value.outcome !== "success" && value.outcome !== "error")
+    throw new Error("Proxy returned an invalid request status");
+  const status = {
+    requestId: value.requestId,
+    targetPeerId: value.targetPeerId,
+    queuedAt: value.queuedAt,
+    stage: value.stage,
+    state: value.state,
+    outcome: value.outcome,
+    ...parseObservations(value)
+  };
+  if ("dispatchedAt" in value && typeof value.dispatchedAt === "number")
+    status.dispatchedAt = value.dispatchedAt;
+  if ("settledAt" in value && typeof value.settledAt === "number")
+    status.settledAt = value.settledAt;
+  if ("waiterEndedAt" in value && typeof value.waiterEndedAt === "number")
+    status.waiterEndedAt = value.waiterEndedAt;
+  if ("response" in value)
+    status.response = value.response;
+  if ("error" in value)
+    status.error = value.error;
+  if ("resultUnavailable" in value) {
+    const unavailable = value.resultUnavailable;
+    if (!unavailable || typeof unavailable !== "object" || !("reason" in unavailable) || unavailable.reason !== "size_limit" && unavailable.reason !== "serialization_failed" && unavailable.reason !== "retention_capacity" || !("limitBytes" in unavailable) || typeof unavailable.limitBytes !== "number")
+      throw new Error("Proxy returned invalid result availability");
+    status.resultUnavailable = {
+      reason: unavailable.reason,
+      limitBytes: unavailable.limitBytes,
+      ..."bytes" in unavailable && typeof unavailable.bytes === "number" ? { bytes: unavailable.bytes } : {}
+    };
+  }
+  return status;
+}
 function peerPublicationChanged(previous, current) {
   return previous === void 0 || previous.transportPeerId !== current.transportPeerId || previous.instanceId !== current.instanceId || previous.multiplayerGroupId !== current.multiplayerGroupId || previous.role !== current.role || previous.placeId !== current.placeId || previous.placeName !== current.placeName || previous.placeKey !== current.placeKey || previous.dataModelName !== current.dataModelName || previous.isRunning !== current.isRunning || previous.pluginVersion !== current.pluginVersion || previous.pluginVariant !== current.pluginVariant || previous.serverVersion !== current.serverVersion;
 }
@@ -13587,16 +14170,52 @@ var ProxyBridgeService = class _ProxyBridgeService extends BridgeService {
   /** Called when this proxy is being discarded (e.g. promotion to primary
       replaced it). Stops the background refresh so it doesn't leak. */
   stop() {
-    if (this.refreshTimer) {
-      clearInterval(this.refreshTimer);
-      this.refreshTimer = void 0;
-    }
+    clearInterval(this.refreshTimer);
+    this.refreshTimer = void 0;
+  }
+  async getRequestStatusEverywhere(requestId) {
+    const response = await fetch(`${this.primaryBaseUrl}/request-status?requestId=${encodeURIComponent(requestId)}`, {
+      headers: this.authHeaders()
+    });
+    if (!response.ok)
+      throw new Error(`Proxy request status failed (${response.status})`);
+    const body = await response.json();
+    if (!body || typeof body !== "object" || !("status" in body))
+      throw new Error("Proxy returned an invalid request status response");
+    if (body.status === null)
+      return void 0;
+    const status = parseRequestStatus(body.status);
+    if (status.requestId !== requestId)
+      throw new Error("Proxy returned status for a different request");
+    return status;
   }
-  async sendRequest(endpoint, data, targetPeerId, timeoutMs = this.proxyRequestTimeout, signal) {
+  async sendRequest(endpoint, data, targetPeerId, timeoutMs = this.proxyRequestTimeout, signal, operationId) {
+    const requestId = operationId ?? randomUUID4();
+    const details = { requestId, targetPeerId, stage: "queued", outcome: "not_executed", executionOutcome: "not_executed" };
+    if (typeof requestId !== "string" || requestId.trim().length === 0 || requestId.length > 128) {
+      throw new RequestFailure("operationId must be a nonempty string of at most 128 characters", "invalid_operation_id", details);
+    }
     if (signal?.aborted)
-      throw new Error("Request aborted");
+      throw new RequestFailure(`Request aborted: ${requestId}; queued; not_executed`, "request_aborted", details);
     const controller = new AbortController();
     const effectiveTimeoutMs = Math.max(1, timeoutMs);
+    let requestBody;
+    try {
+      requestBody = JSON.stringify({
+        endpoint,
+        data,
+        targetPeerId,
+        proxyInstanceId: this.proxyInstanceId,
+        timeoutMs: effectiveTimeoutMs,
+        operationId: requestId
+      });
+    } catch {
+      throw new RequestFailure(`Request ${requestId} cannot be serialized at proxy admission; queued; not_executed`, "request_serialization_failed", details);
+    }
+    const requestBytes = Buffer.byteLength(requestBody);
+    if (requestBytes > HTTP_BODY_LIMIT_BYTES) {
+      throw new RequestFailure(`Request ${requestId} is ${requestBytes} bytes at proxy_send; limit ${HTTP_BODY_LIMIT_BYTES} bytes; queued; not_executed`, "request_too_large", { ...details, bytes: requestBytes, limitBytes: HTTP_BODY_LIMIT_BYTES, transportStage: "proxy_send" });
+    }
     let timedOut = false;
     const abortFromCaller = () => controller.abort();
     signal?.addEventListener("abort", abortFromCaller, { once: true });
@@ -13606,39 +14225,54 @@ var ProxyBridgeService = class _ProxyBridgeService extends BridgeService {
       timedOut = true;
       controller.abort();
     }, effectiveTimeoutMs + PROXY_RESPONSE_GRACE_MS);
+    let primaryError = false;
     try {
       const response = await fetch(`${this.primaryBaseUrl}/proxy`, {
         method: "POST",
         headers: this.authHeaders({ "Content-Type": "application/json" }),
-        body: JSON.stringify({
-          endpoint,
-          data,
-          targetPeerId,
-          proxyInstanceId: this.proxyInstanceId,
-          timeoutMs: effectiveTimeoutMs
-        }),
+        body: requestBody,
         signal: controller.signal
       });
-      if (!response.ok) {
-        const body = await response.text();
-        throw new Error(`Proxy request failed (${response.status}): ${body}`);
+      const body = await response.text();
+      let result;
+      try {
+        result = JSON.parse(body);
+      } catch {
+        throw new Error(`Proxy request failed (${response.status}): ${body || response.statusText}`);
       }
-      const result = await response.json();
       if (!result || typeof result !== "object" || Array.isArray(result)) {
         throw new Error("Proxy returned an invalid response");
       }
-      if ("error" in result && typeof result.error === "string" && result.error.length > 0) {
-        throw new Error(result.error);
+      if ("error" in result && result.error !== void 0 && typeof result.error !== "string") {
+        primaryError = true;
+        throw result.error;
+      }
+      if ("error" in result && typeof result.error === "string") {
+        const details2 = "details" in result ? parseFailureDetails(result.details, { requestId, targetPeerId }) : void 0;
+        if (details2 && "code" in result && typeof result.code === "string") {
+          throw new RequestFailure(result.error, result.code, details2);
+        }
+        throw new RequestFailure(result.error, "studio_response_error", {
+          requestId,
+          targetPeerId,
+          stage: "dispatched",
+          outcome: "unknown",
+          executionOutcome: "unknown"
+        });
+      }
+      if (!response.ok) {
+        throw new Error(`Proxy request failed (${response.status}): ${body || response.statusText}`);
       }
       return "response" in result ? result.response : void 0;
     } catch (error) {
+      if (error instanceof RequestFailure || primaryError)
+        throw error;
       const isAbortError = error instanceof Error ? error.name === "AbortError" : !!error && typeof error === "object" && "name" in error && error.name === "AbortError";
       if (isAbortError) {
-        if (!timedOut && signal?.aborted)
-          throw new Error("Request aborted");
-        throw new Error("Proxy request timeout");
+        const message = !timedOut && signal?.aborted ? "Request aborted" : "Proxy request timeout";
+        throw new RequestFailure(`${message}: ${requestId}; dispatched to primary; unknown; use get_request_status`, !timedOut && signal?.aborted ? "request_aborted" : "proxy_request_timeout", { requestId, targetPeerId, stage: "dispatched", outcome: "unknown", executionOutcome: "unknown", transportStage: "proxy_send" });
       }
-      throw error;
+      throw new RequestFailure(`Proxy connection lost: ${requestId}; dispatched to primary; unknown; use get_request_status. ${error instanceof Error ? error.message : String(error)}`, "proxy_connection_lost", { requestId, targetPeerId, stage: "dispatched", outcome: "unknown", executionOutcome: "unknown", connectionLostAt: Date.now(), transportStage: "proxy_send" });
     } finally {
       clearTimeout(timeoutId);
       signal?.removeEventListener("abort", abortFromCaller);
@@ -13650,6 +14284,251 @@ var ProxyBridgeService = class _ProxyBridgeService extends BridgeService {
   }
 };
 
+// ../core/dist/stdio-transport.js
+import { parseJSONRPCMessage } from "@modelcontextprotocol/server";
+import { TextDecoder } from "util";
+var MAX_STDIO_LINE_BYTES = 80 * 1024 * 1024;
+var MAX_STDIO_PENDING_OUTPUT_BYTES = 256 * 1024 * 1024;
+var INITIAL_BUFFER_BYTES = 64 * 1024;
+var BoundedStdioTransport = class {
+  input;
+  output;
+  onclose;
+  onerror;
+  onmessage;
+  limitBytes;
+  outputLimitBytes;
+  decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+  buffer;
+  lineBytes = 0;
+  started = false;
+  closed = false;
+  inputEnded = false;
+  outputBlocked = false;
+  pendingChunk;
+  pendingWrites = 0;
+  pendingSends = /* @__PURE__ */ new Set();
+  constructor(input = process.stdin, output = process.stdout, options = {}) {
+    this.input = input;
+    this.output = output;
+    this.limitBytes = options.maxBufferSize ?? MAX_STDIO_LINE_BYTES;
+    this.outputLimitBytes = options.maxPendingOutputBytes ?? MAX_STDIO_PENDING_OUTPUT_BYTES;
+    if (!Number.isSafeInteger(this.limitBytes) || this.limitBytes < 1) {
+      throw new RangeError("Stdio line limit must be a positive safe integer");
+    }
+    if (!Number.isSafeInteger(this.outputLimitBytes) || this.outputLimitBytes < 1) {
+      throw new RangeError("Stdio output limit must be a positive safe integer");
+    }
+  }
+  async start() {
+    if (this.started || this.closed)
+      throw new Error("Stdio transport cannot be started again");
+    if (this.input.readableEncoding)
+      throw new Error("Stdio transport requires a byte stream, not a decoded string stream");
+    this.started = true;
+    this.input.on("data", this.onData);
+    this.input.on("error", this.onStreamError);
+    this.input.on("end", this.onEnd);
+    this.input.on("close", this.onInputClose);
+    this.output.on("error", this.onStreamError);
+    this.output.on("close", this.onOutputClose);
+    this.output.on("drain", this.onDrain);
+  }
+  onData = (chunk) => {
+    let offset = 0;
+    while (offset < chunk.length && !this.closed) {
+      if (this.outputBlocked) {
+        this.pendingChunk = chunk.subarray(offset);
+        return;
+      }
+      const newline = chunk.indexOf(10, offset);
+      const end = newline === -1 ? chunk.length : newline;
+      const bytes = end - offset;
+      const previousBytes = this.lineBytes;
+      this.lineBytes += bytes;
+      if (this.lineBytes > this.limitBytes) {
+        this.buffer = void 0;
+      } else if (previousBytes === 0 && newline !== -1) {
+        this.buffer = chunk.subarray(offset, end);
+      } else if (bytes > 0) {
+        if (!this.buffer || this.buffer.length < this.lineBytes) {
+          const capacity = Math.min(this.limitBytes, Math.max(INITIAL_BUFFER_BYTES, this.lineBytes, (this.buffer?.length ?? 0) * 2));
+          const grown = Buffer.allocUnsafe(capacity);
+          this.buffer?.copy(grown, 0, 0, previousBytes);
+          this.buffer = grown;
+        }
+        chunk.copy(this.buffer, previousBytes, offset, end);
+      }
+      offset = end + 1;
+      if (newline !== -1)
+        this.finishLine();
+    }
+  };
+  finishLine() {
+    const bytes = this.lineBytes;
+    const buffer = this.buffer;
+    this.lineBytes = 0;
+    this.buffer = void 0;
+    if (bytes > this.limitBytes) {
+      void this.rejectLine(-32600, "stdio_request_too_large", bytes).catch(() => {
+      });
+      return;
+    }
+    let value;
+    try {
+      value = JSON.parse(this.decoder.decode(buffer?.subarray(0, bytes)));
+    } catch {
+      void this.rejectLine(-32700, "stdio_parse_error", bytes).catch(() => {
+      });
+      return;
+    }
+    let message;
+    try {
+      message = parseJSONRPCMessage(value);
+    } catch {
+      void this.rejectLine(-32600, "stdio_invalid_request", bytes).catch(() => {
+      });
+      return;
+    }
+    try {
+      this.onmessage?.(message);
+    } catch (error) {
+      this.onerror?.(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  rejectLine(code, reason, bytes) {
+    const message = `${reason}: received ${bytes} bytes; limit ${this.limitBytes} bytes; stdio_receive; not_executed`;
+    this.onerror?.(new Error(message));
+    return this.writeMessage({
+      jsonrpc: "2.0",
+      id: null,
+      error: {
+        code,
+        message,
+        data: {
+          code: reason,
+          bytes,
+          limitBytes: this.limitBytes,
+          stage: "stdio_receive",
+          transportStage: "stdio_receive",
+          outcome: "not_executed",
+          executionOutcome: "not_executed"
+        }
+      }
+    });
+  }
+  onEnd = () => {
+    if (this.closed)
+      return;
+    this.inputEnded = true;
+    if (this.pendingChunk)
+      return;
+    const bytes = this.lineBytes;
+    this.lineBytes = 0;
+    this.buffer = void 0;
+    if (bytes > 0) {
+      const oversized = bytes > this.limitBytes;
+      void this.rejectLine(oversized ? -32600 : -32700, oversized ? "stdio_request_too_large" : "stdio_truncated_line", bytes).finally(() => this.close()).catch(() => {
+      });
+    } else {
+      void this.close();
+    }
+  };
+  onInputClose = () => {
+    if (!this.input.readableEnded)
+      this.onEnd();
+  };
+  onOutputClose = () => {
+    void this.close();
+  };
+  onStreamError = (error) => {
+    if (this.closed)
+      return;
+    this.onerror?.(error);
+    void this.close();
+  };
+  onDrain = () => {
+    this.outputBlocked = false;
+    for (const send of this.pendingSends)
+      send.resolve();
+    this.pendingSends.clear();
+    const chunk = this.pendingChunk;
+    this.pendingChunk = void 0;
+    if (chunk && !this.closed)
+      this.onData(chunk);
+    if (this.inputEnded && !this.pendingChunk && !this.closed)
+      this.onEnd();
+    if (!this.outputBlocked && !this.closed)
+      this.input.resume();
+  };
+  send(message) {
+    return this.writeMessage(message);
+  }
+  writeMessage(message) {
+    if (this.closed)
+      return Promise.reject(new Error("Stdio transport is closed"));
+    let json;
+    try {
+      json = JSON.stringify(message) + "\n";
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    const bytes = Buffer.byteLength(json);
+    const queuedBytes = this.output.writableLength + bytes;
+    if (queuedBytes > this.outputLimitBytes) {
+      const error = new Error(`Stdio output backpressure capacity exceeded: ${queuedBytes} bytes; limit ${this.outputLimitBytes} bytes`);
+      this.onStreamError(error);
+      return Promise.reject(error);
+    }
+    const { promise, resolve: resolve5, reject } = Promise.withResolvers();
+    const pending = { resolve: resolve5, reject };
+    this.pendingSends.add(pending);
+    this.pendingWrites++;
+    try {
+      const writable = this.output.write(Buffer.from(json), () => {
+        this.pendingWrites--;
+        if (this.closed && this.pendingWrites === 0) {
+          queueMicrotask(() => this.output.off("error", this.onStreamError));
+        }
+      });
+      if (writable) {
+        this.pendingSends.delete(pending);
+        resolve5();
+      } else if (!this.closed) {
+        this.outputBlocked = true;
+        this.input.pause();
+      }
+    } catch (error) {
+      this.pendingWrites--;
+      this.onStreamError(error instanceof Error ? error : new Error(String(error)));
+    }
+    return promise;
+  }
+  async close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    this.input.off("data", this.onData);
+    this.input.off("error", this.onStreamError);
+    this.input.off("end", this.onEnd);
+    this.input.off("close", this.onInputClose);
+    if (this.pendingWrites === 0)
+      this.output.off("error", this.onStreamError);
+    this.output.off("close", this.onOutputClose);
+    this.output.off("drain", this.onDrain);
+    if (this.input.listenerCount("data") === 0)
+      this.input.pause();
+    this.buffer = void 0;
+    this.pendingChunk = void 0;
+    this.lineBytes = 0;
+    const error = new Error("Stdio transport is closed");
+    for (const send of this.pendingSends)
+      send.reject(error);
+    this.pendingSends.clear();
+    this.onclose?.();
+  }
+};
+
 // ../core/dist/server.js
 var RobloxStudioMCPServer = class {
   tools;
@@ -13743,7 +14622,10 @@ var RobloxStudioMCPServer = class {
           throw new Error(`Unknown tool: ${name}`);
         return handler(tools, args, invocation);
       }
-    }), { onerror: (error) => console.error("[mcp:stdio]", error) });
+    }), {
+      transport: new BoundedStdioTransport(),
+      onerror: (error) => console.error("[mcp:stdio]", error)
+    });
     console.error(`${this.config.name} v${this.config.version} running on stdio`);
     if (primaryApp) {
       primaryApp.setMCPServerActive(true);
@@ -13901,6 +14783,12 @@ var TOOL_DEFINITIONS = [
     inputSchema: {
       type: "object",
       properties: {
+        operation_id: {
+          type: "string",
+          minLength: 1,
+          maxLength: 128,
+          description: "Unique recovery ID; reuse only for identical arguments."
+        },
         instancePath: {
           type: "string",
           description: "Canonical path of the target instance."
@@ -14076,7 +14964,7 @@ var TOOL_DEFINITIONS = [
         action: {
           type: "string",
           enum: ["get", "set", "view"],
-          description: "View frames the target."
+          description: "View frames a target or the current selection and preserves the camera type."
         },
         paths: {
           type: "array",
@@ -14092,7 +14980,7 @@ var TOOL_DEFINITIONS = [
         path: {
           type: "string",
           minLength: 1,
-          description: "View needs a BasePart or Model path."
+          description: "Optional BasePart or Model path for view; omit to frame exactly one selected BasePart or Model."
         },
         from: {
           type: "number",
@@ -14126,6 +15014,12 @@ var TOOL_DEFINITIONS = [
     inputSchema: {
       type: "object",
       properties: {
+        operation_id: {
+          type: "string",
+          minLength: 1,
+          maxLength: 128,
+          description: "Unique recovery ID; reuse only for identical arguments."
+        },
         code: {
           type: "string",
           description: "Luau code to execute."
@@ -14970,6 +15864,23 @@ var TOOL_DEFINITIONS = [
       properties: {}
     }
   },
+  {
+    name: "get_request_status",
+    category: "read",
+    description: "Use to recover a retained Studio operation outcome after a timeout.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        request_id: {
+          type: "string",
+          minLength: 1,
+          maxLength: 128,
+          description: "Caller operation ID or request ID from a server error."
+        }
+      },
+      required: ["request_id"]
+    }
+  },
   // === Asset Tools ===
   {
     name: "search_assets",