@reactor-team/js-sdk 2.2.2 → 2.3.2

package/dist/index.mjs

@@ -184,12 +184,13 @@ function waitForIceGathering(pc, timeoutMs = 5e3) {
     }, timeoutMs);
   });
 }
-function sendMessage(channel, command, data) {
+function sendMessage(channel, command, data, scope = "application") {
   if (channel.readyState !== "open") {
     throw new Error(`Data channel not open: ${channel.readyState}`);
   }
   const jsonData = typeof data === "string" ? JSON.parse(data) : data;
-  const payload = { type: command, data: jsonData };
+  const inner = { type: command, data: jsonData };
+  const payload = { scope, data: inner };
   channel.send(JSON.stringify(payload));
 }
 function parseMessage(data) {
@@ -208,8 +209,9 @@ function closePeerConnection(pc) {
 
 // src/core/CoordinatorClient.ts
 var INITIAL_BACKOFF_MS = 500;
-var MAX_BACKOFF_MS = 3e4;
+var MAX_BACKOFF_MS = 15e3;
 var BACKOFF_MULTIPLIER = 2;
+var DEFAULT_MAX_ATTEMPTS = 6;
 var CoordinatorClient = class {
   constructor(options) {
     this.baseUrl = options.baseUrl;
@@ -402,13 +404,14 @@ var CoordinatorClient = class {
     });
   }
   /**
-   * Polls for the SDP answer with geometric backoff.
+   * Polls for the SDP answer with exponential backoff.
    * Used for async reconnection when the answer is not immediately available.
    * @param sessionId - The session ID to poll for
+   * @param maxAttempts - Optional maximum number of polling attempts before giving up
    * @returns The SDP answer from the server
    */
-  pollSdpAnswer(sessionId) {
-    return __async(this, null, function* () {
+  pollSdpAnswer(_0) {
+    return __async(this, arguments, function* (sessionId, maxAttempts = DEFAULT_MAX_ATTEMPTS) {
       console.debug(
         "[CoordinatorClient] Polling for SDP answer for session:",
         sessionId
@@ -416,9 +419,14 @@ var CoordinatorClient = class {
       let backoffMs = INITIAL_BACKOFF_MS;
       let attempt = 0;
       while (true) {
+        if (attempt >= maxAttempts) {
+          throw new Error(
+            `SDP polling exceeded maximum attempts (${maxAttempts}) for session ${sessionId}`
+          );
+        }
         attempt++;
         console.debug(
-          `[CoordinatorClient] SDP poll attempt ${attempt} for session ${sessionId}`
+          `[CoordinatorClient] SDP poll attempt ${attempt}/${maxAttempts} for session ${sessionId}`
         );
         const response = yield fetch(
           `${this.baseUrl}/sessions/${sessionId}/sdp_params`,
@@ -455,9 +463,10 @@ var CoordinatorClient = class {
    * falls back to polling. If no sdpOffer is provided, goes directly to polling.
    * @param sessionId - The session ID to connect to
    * @param sdpOffer - Optional SDP offer from the local WebRTC peer connection
+   * @param maxAttempts - Optional maximum number of polling attempts before giving up
    * @returns The SDP answer from the server
    */
-  connect(sessionId, sdpOffer) {
+  connect(sessionId, sdpOffer, maxAttempts) {
     return __async(this, null, function* () {
       console.debug("[CoordinatorClient] Connecting to session:", sessionId);
       if (sdpOffer) {
@@ -466,7 +475,7 @@ var CoordinatorClient = class {
           return answer;
         }
       }
-      return this.pollSdpAnswer(sessionId);
+      return this.pollSdpAnswer(sessionId, maxAttempts);
     });
   }
   /**
@@ -571,6 +580,7 @@ var LocalCoordinatorClient = class extends CoordinatorClient {
 };
 
 // src/core/GPUMachineClient.ts
+var PING_INTERVAL_MS = 5e3;
 var GPUMachineClient = class {
   constructor(config) {
     this.eventListeners = /* @__PURE__ */ new Map();
@@ -653,6 +663,7 @@ var GPUMachineClient = class {
    */
   disconnect() {
     return __async(this, null, function* () {
+      this.stopPing();
       if (this.publishedTrack) {
         yield this.unpublishTrack();
       }
@@ -693,13 +704,14 @@ var GPUMachineClient = class {
    * Sends a command to the GPU machine via the data channel.
    * @param command The command to send
    * @param data The data to send with the command. These are the parameters for the command, matching the scheme in the capabilities dictionary.
+   * @param scope The message scope – "application" (default) for model commands, "runtime" for platform-level messages.
    */
-  sendCommand(command, data) {
+  sendCommand(command, data, scope = "application") {
     if (!this.dataChannel) {
       throw new Error("[GPUMachineClient] Data channel not available");
     }
     try {
-      sendMessage(this.dataChannel, command, data);
+      sendMessage(this.dataChannel, command, data, scope);
     } catch (error) {
       console.warn("[GPUMachineClient] Failed to send message:", error);
     }
@@ -780,6 +792,34 @@ var GPUMachineClient = class {
     return new MediaStream(tracks);
   }
   // ─────────────────────────────────────────────────────────────────────────────
+  // Ping (Client Liveness)
+  // ─────────────────────────────────────────────────────────────────────────────
+  /**
+   * Starts sending periodic "ping" messages on the runtime channel so the
+   * server can detect stale connections quickly.
+   */
+  startPing() {
+    this.stopPing();
+    this.pingInterval = setInterval(() => {
+      var _a;
+      if (((_a = this.dataChannel) == null ? void 0 : _a.readyState) === "open") {
+        try {
+          sendMessage(this.dataChannel, "ping", {}, "runtime");
+        } catch (e) {
+        }
+      }
+    }, PING_INTERVAL_MS);
+  }
+  /**
+   * Stops the periodic ping.
+   */
+  stopPing() {
+    if (this.pingInterval !== void 0) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = void 0;
+    }
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
   // Private Helpers
   // ─────────────────────────────────────────────────────────────────────────────
   setStatus(newStatus) {
@@ -833,18 +873,29 @@ var GPUMachineClient = class {
     if (!this.dataChannel) return;
     this.dataChannel.onopen = () => {
       console.debug("[GPUMachineClient] Data channel open");
+      this.startPing();
     };
     this.dataChannel.onclose = () => {
       console.debug("[GPUMachineClient] Data channel closed");
+      this.stopPing();
     };
     this.dataChannel.onerror = (error) => {
       console.error("[GPUMachineClient] Data channel error:", error);
     };
     this.dataChannel.onmessage = (event) => {
-      const data = parseMessage(event.data);
-      console.debug("[GPUMachineClient] Received message:", data);
+      const rawData = parseMessage(event.data);
+      console.debug("[GPUMachineClient] Received message:", rawData);
       try {
-        this.emit("application", data);
+        if ((rawData == null ? void 0 : rawData.scope) === "application" && (rawData == null ? void 0 : rawData.data) !== void 0) {
+          this.emit("message", rawData.data, "application");
+        } else if ((rawData == null ? void 0 : rawData.scope) === "runtime" && (rawData == null ? void 0 : rawData.data) !== void 0) {
+          this.emit("message", rawData.data, "runtime");
+        } else {
+          console.warn(
+            "[GPUMachineClient] Received message without envelope, treating as application"
+          );
+          this.emit("message", rawData, "application");
+        }
       } catch (error) {
         console.error(
           "[GPUMachineClient] Failed to parse/validate message:",
@@ -894,11 +945,14 @@ var Reactor = class {
   }
   /**
    * Public method to send a message to the machine.
-   * Automatically wraps the message in an application message.
-   * @param message The message to send to the machine.
+   * Wraps the message in the specified channel envelope (defaults to "application").
+   * @param command The command name to send.
+   * @param data The command payload.
+   * @param scope The envelope scope – "application" (default) for model commands,
+   *              "runtime" for platform-level messages (e.g. requestCapabilities).
    * @throws Error if not in ready state
    */
-  sendCommand(command, data) {
+  sendCommand(command, data, scope = "application") {
     return __async(this, null, function* () {
       var _a;
       if (process.env.NODE_ENV !== "development" && this.status !== "ready") {
@@ -907,7 +961,7 @@ var Reactor = class {
         return;
       }
       try {
-        (_a = this.machineClient) == null ? void 0 : _a.sendCommand(command, data);
+        (_a = this.machineClient) == null ? void 0 : _a.sendCommand(command, data, scope);
       } catch (error) {
         console.error("[Reactor] Failed to send message:", error);
         this.createError(
@@ -965,8 +1019,9 @@ var Reactor = class {
   }
   /**
    * Public method for reconnecting to an existing session, that may have been interrupted but can be recovered.
+   * @param options Optional connect options (e.g. maxAttempts for SDP polling)
    */
-  reconnect() {
+  reconnect(options) {
     return __async(this, null, function* () {
       if (!this.sessionId || !this.coordinatorClient) {
         console.warn("[Reactor] No active session to reconnect to.");
@@ -986,7 +1041,8 @@ var Reactor = class {
       try {
         const sdpAnswer = yield this.coordinatorClient.connect(
           this.sessionId,
-          sdpOffer
+          sdpOffer,
+          options == null ? void 0 : options.maxAttempts
         );
         yield this.machineClient.connect(sdpAnswer);
         this.setStatus("ready");
@@ -1010,8 +1066,10 @@ var Reactor = class {
    * Connects to the coordinator and waits for a GPU to be assigned.
    * Once a GPU is assigned, the Reactor will connect to the gpu machine via WebRTC.
    * If no authentication is provided and not in local mode, an error is thrown.
+   * @param jwtToken Optional JWT token for authentication
+   * @param options Optional connect options (e.g. maxAttempts for SDP polling)
    */
-  connect(jwtToken) {
+  connect(jwtToken, options) {
     return __async(this, null, function* () {
       console.debug("[Reactor] Connecting, status:", this.status);
       if (jwtToken == void 0 && !this.local) {
@@ -1028,7 +1086,7 @@ var Reactor = class {
         this.coordinatorClient = this.local ? new LocalCoordinatorClient(this.coordinatorUrl) : new CoordinatorClient({
           baseUrl: this.coordinatorUrl,
           jwtToken,
-          // Safe: validated on line 186-188
+          // Safe: validated above
           model: this.model
         });
         const iceServers = yield this.coordinatorClient.getIceServers();
@@ -1037,7 +1095,11 @@ var Reactor = class {
         const sdpOffer = yield this.machineClient.createOffer();
         const sessionId = yield this.coordinatorClient.createSession(sdpOffer);
         this.setSessionId(sessionId);
-        const sdpAnswer = yield this.coordinatorClient.connect(sessionId);
+        const sdpAnswer = yield this.coordinatorClient.connect(
+          sessionId,
+          void 0,
+          options == null ? void 0 : options.maxAttempts
+        );
         yield this.machineClient.connect(sdpAnswer);
       } catch (error) {
         console.error("[Reactor] Connection failed:", error);
@@ -1047,7 +1109,14 @@ var Reactor = class {
           "coordinator",
           true
         );
-        this.setStatus("disconnected");
+        try {
+          yield this.disconnect(false);
+        } catch (disconnectError) {
+          console.error(
+            "[Reactor] Failed to clean up after connection failure:",
+            disconnectError
+          );
+        }
         throw error;
       }
     });
@@ -1057,12 +1126,8 @@ var Reactor = class {
    */
   setupMachineClientHandlers() {
     if (!this.machineClient) return;
-    this.machineClient.on("application", (message) => {
-      if ((message == null ? void 0 : message.type) === "application" && (message == null ? void 0 : message.data) !== void 0) {
-        this.emit("newMessage", message.data);
-      } else {
-        this.emit("newMessage", message);
-      }
+    this.machineClient.on("message", (message, scope) => {
+      this.emit("newMessage", message, scope);
     });
     this.machineClient.on("statusChanged", (status) => {
       switch (status) {
@@ -1269,23 +1334,27 @@ var createReactorStore = (initProps, publicState = defaultInitState) => {
           get().internal.reactor.off("newMessage", handler);
         };
       },
-      sendCommand: (command, data) => __async(null, null, function* () {
-        console.debug("[ReactorStore] Sending command", { command, data });
+      sendCommand: (command, data, scope) => __async(null, null, function* () {
+        console.debug("[ReactorStore] Sending command", {
+          command,
+          data,
+          scope
+        });
         try {
-          yield get().internal.reactor.sendCommand(command, data);
+          yield get().internal.reactor.sendCommand(command, data, scope);
           console.debug("[ReactorStore] Command sent successfully");
         } catch (error) {
           console.error("[ReactorStore] Failed to send command:", error);
           throw error;
         }
       }),
-      connect: (jwtToken) => __async(null, null, function* () {
+      connect: (jwtToken, options) => __async(null, null, function* () {
         if (jwtToken === void 0) {
           jwtToken = get().jwtToken;
         }
         console.debug("[ReactorStore] Connect called.");
         try {
-          yield get().internal.reactor.connect(jwtToken);
+          yield get().internal.reactor.connect(jwtToken, options);
           console.debug("[ReactorStore] Connect completed successfully");
         } catch (error) {
           console.error("[ReactorStore] Connect failed:", error);
@@ -1330,10 +1399,10 @@ var createReactorStore = (initProps, publicState = defaultInitState) => {
           throw error;
         }
       }),
-      reconnect: () => __async(null, null, function* () {
+      reconnect: (options) => __async(null, null, function* () {
         console.debug("[ReactorStore] Reconnecting");
         try {
-          yield get().internal.reactor.reconnect();
+          yield get().internal.reactor.reconnect(options);
           console.debug("[ReactorStore] Reconnect completed successfully");
         } catch (error) {
           console.error("[ReactorStore] Failed to reconnect:", error);
@@ -1350,11 +1419,11 @@ import { jsx } from "react/jsx-runtime";
 function ReactorProvider(_a) {
   var _b = _a, {
     children,
-    autoConnect = true,
+    connectOptions,
     jwtToken
   } = _b, props = __objRest(_b, [
     "children",
-    "autoConnect",
+    "connectOptions",
     "jwtToken"
   ]);
   const storeRef = useRef(void 0);
@@ -1369,14 +1438,16 @@ function ReactorProvider(_a) {
     );
     console.debug("[ReactorProvider] Reactor store created successfully");
   }
+  const _a2 = connectOptions != null ? connectOptions : {}, { autoConnect = false } = _a2, pollingOptions = __objRest(_a2, ["autoConnect"]);
   const { coordinatorUrl, modelName, local } = props;
+  const maxAttempts = pollingOptions.maxAttempts;
   useEffect(() => {
     const handleBeforeUnload = () => {
-      var _a2;
+      var _a3;
       console.debug(
         "[ReactorProvider] Page unloading, performing non-recoverable disconnect"
       );
-      (_a2 = storeRef.current) == null ? void 0 : _a2.getState().internal.reactor.disconnect(false);
+      (_a3 = storeRef.current) == null ? void 0 : _a3.getState().internal.reactor.disconnect(false);
     };
     window.addEventListener("beforeunload", handleBeforeUnload);
     return () => {
@@ -1391,7 +1462,7 @@ function ReactorProvider(_a) {
         console.debug(
           "[ReactorProvider] Starting autoconnect in first render..."
         );
-        current2.getState().connect(jwtToken).then(() => {
+        current2.getState().connect(jwtToken, pollingOptions).then(() => {
           console.debug(
             "[ReactorProvider] Autoconnect successful in first render"
           );
@@ -1434,7 +1505,7 @@ function ReactorProvider(_a) {
     );
     if (autoConnect && current.getState().status === "disconnected" && jwtToken) {
       console.debug("[ReactorProvider] Starting autoconnect...");
-      current.getState().connect(jwtToken).then(() => {
+      current.getState().connect(jwtToken, pollingOptions).then(() => {
         console.debug("[ReactorProvider] Autoconnect successful");
       }).catch((error) => {
         console.error("[ReactorProvider] Failed to autoconnect:", error);
@@ -1450,7 +1521,7 @@ function ReactorProvider(_a) {
         console.error("[ReactorProvider] Failed to disconnect:", error);
       });
     };
-  }, [coordinatorUrl, modelName, autoConnect, local, jwtToken]);
+  }, [coordinatorUrl, modelName, autoConnect, local, jwtToken, maxAttempts]);
   return /* @__PURE__ */ jsx(ReactorContext.Provider, { value: storeRef.current, children });
 }
 function useReactorStore(selector) {
@@ -1475,9 +1546,12 @@ function useReactorMessage(handler) {
   }, [handler]);
   useEffect2(() => {
     console.debug("[useReactorMessage] Setting up message subscription");
-    const stableHandler = (message) => {
-      console.debug("[useReactorMessage] Message received", { message });
-      handlerRef.current(message);
+    const stableHandler = (message, scope) => {
+      console.debug("[useReactorMessage] Message received", {
+        message,
+        scope
+      });
+      handlerRef.current(message, scope);
     };
     reactor.on("newMessage", stableHandler);
     console.debug("[useReactorMessage] Message handler registered");
@@ -1606,7 +1680,7 @@ function ReactorController({
   }, [status]);
   const requestCapabilities = useCallback(() => {
     if (status === "ready") {
-      sendCommand("requestCapabilities", {});
+      sendCommand("requestCapabilities", {}, "runtime");
     }
   }, [status, sendCommand]);
   React.useEffect(() => {
@@ -1623,9 +1697,9 @@ function ReactorController({
     }, 5e3);
     return () => clearInterval(interval);
   }, [status, commands, requestCapabilities]);
-  useReactorMessage((message) => {
-    if (message && typeof message === "object" && "commands" in message) {
-      const commandsMessage = message;
+  useReactorMessage((message, scope) => {
+    if (scope === "runtime" && message && typeof message === "object" && message.type === "modelCapabilities" && message.data && "commands" in message.data) {
+      const commandsMessage = message.data;
       setCommands(commandsMessage.commands);
       const initialValues = {};
       const initialExpanded = {};