@reactor-team/js-sdk 2.0.1 → 2.1.0

package/dist/index.d.mts

@@ -11,6 +11,9 @@ interface ReactorError {
     component: "coordinator" | "gpu" | "livekit";
     retryAfter?: number;
 }
+declare class ConflictError extends Error {
+    constructor(message: string);
+}
 interface ReactorState$1 {
     status: ReactorStatus;
     lastError?: ReactorError;
@@ -184,4 +187,4 @@ declare function useReactorMessage(handler: (message: any) => void): void;
  */
 declare function fetchInsecureJwtToken(apiKey: string, coordinatorUrl?: string): Promise<string>;
 
-export { type Options, PROD_COORDINATOR_URL, Reactor, ReactorController, type ReactorControllerProps, type ReactorError, type ReactorEvent, ReactorProvider, type ReactorState$1 as ReactorState, type ReactorStatus, ReactorView, type ReactorViewProps, WebcamStream, fetchInsecureJwtToken, useReactor, useReactorMessage, useReactorStore };
+export { ConflictError, type Options, PROD_COORDINATOR_URL, Reactor, ReactorController, type ReactorControllerProps, type ReactorError, type ReactorEvent, ReactorProvider, type ReactorState$1 as ReactorState, type ReactorStatus, ReactorView, type ReactorViewProps, WebcamStream, fetchInsecureJwtToken, useReactor, useReactorMessage, useReactorStore };

package/dist/index.d.ts

@@ -11,6 +11,9 @@ interface ReactorError {
     component: "coordinator" | "gpu" | "livekit";
     retryAfter?: number;
 }
+declare class ConflictError extends Error {
+    constructor(message: string);
+}
 interface ReactorState$1 {
     status: ReactorStatus;
     lastError?: ReactorError;
@@ -184,4 +187,4 @@ declare function useReactorMessage(handler: (message: any) => void): void;
  */
 declare function fetchInsecureJwtToken(apiKey: string, coordinatorUrl?: string): Promise<string>;
 
-export { type Options, PROD_COORDINATOR_URL, Reactor, ReactorController, type ReactorControllerProps, type ReactorError, type ReactorEvent, ReactorProvider, type ReactorState$1 as ReactorState, type ReactorStatus, ReactorView, type ReactorViewProps, WebcamStream, fetchInsecureJwtToken, useReactor, useReactorMessage, useReactorStore };
+export { ConflictError, type Options, PROD_COORDINATOR_URL, Reactor, ReactorController, type ReactorControllerProps, type ReactorError, type ReactorEvent, ReactorProvider, type ReactorState$1 as ReactorState, type ReactorStatus, ReactorView, type ReactorViewProps, WebcamStream, fetchInsecureJwtToken, useReactor, useReactorMessage, useReactorStore };

package/dist/index.js

@@ -79,6 +79,7 @@ var __async = (__this, __arguments, generator) => {
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ConflictError: () => ConflictError,
   PROD_COORDINATOR_URL: () => PROD_COORDINATOR_URL,
   Reactor: () => Reactor,
   ReactorController: () => ReactorController,
@@ -92,6 +93,158 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/types.ts
+var ConflictError = class extends Error {
+  constructor(message) {
+    super(message);
+  }
+};
+
+// src/core/types.ts
+var import_zod = require("zod");
+var SessionState = /* @__PURE__ */ ((SessionState2) => {
+  SessionState2[SessionState2["SESSION_STATE_UNKNOWN"] = 0] = "SESSION_STATE_UNKNOWN";
+  SessionState2[SessionState2["SESSION_STATE_WAITING"] = 1] = "SESSION_STATE_WAITING";
+  SessionState2[SessionState2["SESSION_STATE_ACTIVE"] = 2] = "SESSION_STATE_ACTIVE";
+  SessionState2[SessionState2["SESSION_STATE_DISCONNECTED"] = 3] = "SESSION_STATE_DISCONNECTED";
+  SessionState2[SessionState2["SESSION_STATE_CLOSED"] = 4] = "SESSION_STATE_CLOSED";
+  SessionState2[SessionState2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+  return SessionState2;
+})(SessionState || {});
+var CreateSessionRequestSchema = import_zod.z.object({
+  model: import_zod.z.string(),
+  sdp_offer: import_zod.z.string(),
+  extra_args: import_zod.z.record(import_zod.z.string(), import_zod.z.any())
+  // Dictionary
+});
+var CreateSessionResponseSchema = import_zod.z.object({
+  session_id: import_zod.z.uuidv4()
+});
+var SessionStatusResponseSchema = import_zod.z.object({
+  session_id: import_zod.z.uuidv4(),
+  state: SessionState
+});
+var SessionInfoResponseSchema = SessionStatusResponseSchema.extend({
+  session_info: CreateSessionRequestSchema.extend({
+    session_id: import_zod.z.uuidv4()
+  })
+});
+var SDPParamsRequestSchema = import_zod.z.object({
+  sdp_offer: import_zod.z.string(),
+  extra_args: import_zod.z.record(import_zod.z.string(), import_zod.z.any())
+  // Dictionary
+});
+var SDPParamsResponseSchema = import_zod.z.object({
+  sdp_answer: import_zod.z.string(),
+  extra_args: import_zod.z.record(import_zod.z.string(), import_zod.z.any())
+  // Dictionary
+});
+var IceServersResponseSchema = import_zod.z.object({
+  ice_servers: import_zod.z.array(
+    import_zod.z.object({
+      uris: import_zod.z.array(import_zod.z.string()),
+      credentials: import_zod.z.object({
+        username: import_zod.z.string(),
+        password: import_zod.z.string()
+      }).optional()
+    })
+  )
+});
+
+// src/utils/webrtc.ts
+var DEFAULT_DATA_CHANNEL_LABEL = "data";
+var FORCE_RELAY_MODE = false;
+function createPeerConnection(config) {
+  return new RTCPeerConnection({
+    iceServers: config.iceServers,
+    iceTransportPolicy: FORCE_RELAY_MODE ? "relay" : "all"
+  });
+}
+function createDataChannel(pc, label) {
+  return pc.createDataChannel(label != null ? label : DEFAULT_DATA_CHANNEL_LABEL);
+}
+function createOffer(pc) {
+  return __async(this, null, function* () {
+    const offer = yield pc.createOffer();
+    yield pc.setLocalDescription(offer);
+    yield waitForIceGathering(pc);
+    const localDescription = pc.localDescription;
+    if (!localDescription) {
+      throw new Error("Failed to create local description");
+    }
+    return localDescription.sdp;
+  });
+}
+function setRemoteDescription(pc, sdp) {
+  return __async(this, null, function* () {
+    const sessionDescription = new RTCSessionDescription({
+      sdp,
+      type: "answer"
+    });
+    yield pc.setRemoteDescription(sessionDescription);
+  });
+}
+function getLocalDescription(pc) {
+  const desc = pc.localDescription;
+  if (!desc) return void 0;
+  return desc.sdp;
+}
+function transformIceServers(response) {
+  return response.ice_servers.map((server) => {
+    const rtcServer = {
+      urls: server.uris
+    };
+    if (server.credentials) {
+      rtcServer.username = server.credentials.username;
+      rtcServer.credential = server.credentials.password;
+    }
+    return rtcServer;
+  });
+}
+function waitForIceGathering(pc, timeoutMs = 5e3) {
+  return new Promise((resolve) => {
+    if (pc.iceGatheringState === "complete") {
+      resolve();
+      return;
+    }
+    const onGatheringStateChange = () => {
+      if (pc.iceGatheringState === "complete") {
+        pc.removeEventListener(
+          "icegatheringstatechange",
+          onGatheringStateChange
+        );
+        resolve();
+      }
+    };
+    pc.addEventListener("icegatheringstatechange", onGatheringStateChange);
+    setTimeout(() => {
+      pc.removeEventListener("icegatheringstatechange", onGatheringStateChange);
+      resolve();
+    }, timeoutMs);
+  });
+}
+function sendMessage(channel, command, data) {
+  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 };
+  channel.send(JSON.stringify(payload));
+}
+function parseMessage(data) {
+  if (typeof data === "string") {
+    try {
+      return JSON.parse(data);
+    } catch (e) {
+      return data;
+    }
+  }
+  return data;
+}
+function closePeerConnection(pc) {
+  pc.close();
+}
+
 // src/core/CoordinatorClient.ts
 var INITIAL_BACKOFF_MS = 500;
 var MAX_BACKOFF_MS = 3e4;
@@ -110,6 +263,33 @@ var CoordinatorClient = class {
       Authorization: `Bearer ${this.jwtToken}`
     };
   }
+  /**
+   * Fetches ICE servers from the coordinator.
+   * @returns Array of RTCIceServer objects for WebRTC peer connection configuration
+   */
+  getIceServers() {
+    return __async(this, null, function* () {
+      console.debug("[CoordinatorClient] Fetching ICE servers...");
+      const response = yield fetch(
+        `${this.baseUrl}/ice_servers?model=${this.model}`,
+        {
+          method: "GET",
+          headers: this.getAuthHeaders()
+        }
+      );
+      if (!response.ok) {
+        throw new Error(`Failed to fetch ICE servers: ${response.status}`);
+      }
+      const data = yield response.json();
+      const parsed = IceServersResponseSchema.parse(data);
+      const iceServers = transformIceServers(parsed);
+      console.debug(
+        "[CoordinatorClient] Received ICE servers:",
+        iceServers.length
+      );
+      return iceServers;
+    });
+  }
   /**
    * Creates a new session with the coordinator.
    * Expects a 200 response and stores the session ID.
@@ -346,6 +526,29 @@ var LocalCoordinatorClient = class extends CoordinatorClient {
     });
     this.localBaseUrl = baseUrl;
   }
+  /**
+   * Gets ICE servers from the local HTTP runtime.
+   * @returns The ICE server configuration
+   */
+  getIceServers() {
+    return __async(this, null, function* () {
+      console.debug("[LocalCoordinatorClient] Fetching ICE servers...");
+      const response = yield fetch(`${this.localBaseUrl}/ice_servers`, {
+        method: "GET"
+      });
+      if (!response.ok) {
+        throw new Error("Failed to get ICE servers from local coordinator.");
+      }
+      const data = yield response.json();
+      const parsed = IceServersResponseSchema.parse(data);
+      const iceServers = transformIceServers(parsed);
+      console.debug(
+        "[LocalCoordinatorClient] Received ICE servers:",
+        iceServers.length
+      );
+      return iceServers;
+    });
+  }
   /**
    * Creates a local session by posting to /start_session.
    * @returns always "local"
@@ -386,6 +589,9 @@ var LocalCoordinatorClient = class extends CoordinatorClient {
         body: JSON.stringify(sdpBody)
       });
       if (!response.ok) {
+        if (response.status === 409) {
+          throw new ConflictError("Connection superseded by newer request");
+        }
         throw new Error("Failed to get SDP answer from local coordinator.");
       }
       const sdpAnswer = yield response.json();
@@ -403,97 +609,12 @@ var LocalCoordinatorClient = class extends CoordinatorClient {
   }
 };
 
-// src/utils/webrtc.ts
-var DEFAULT_ICE_SERVERS = [
-  { urls: "stun:stun.l.google.com:19302" },
-  { urls: "stun:stun1.l.google.com:19302" }
-];
-var DEFAULT_DATA_CHANNEL_LABEL = "data";
-function createPeerConnection(config) {
-  var _a;
-  return new RTCPeerConnection({
-    iceServers: (_a = config == null ? void 0 : config.iceServers) != null ? _a : DEFAULT_ICE_SERVERS
-  });
-}
-function createDataChannel(pc, label) {
-  return pc.createDataChannel(label != null ? label : DEFAULT_DATA_CHANNEL_LABEL);
-}
-function createOffer(pc) {
-  return __async(this, null, function* () {
-    const offer = yield pc.createOffer();
-    yield pc.setLocalDescription(offer);
-    yield waitForIceGathering(pc);
-    const localDescription = pc.localDescription;
-    if (!localDescription) {
-      throw new Error("Failed to create local description");
-    }
-    return localDescription.sdp;
-  });
-}
-function setRemoteDescription(pc, sdp) {
-  return __async(this, null, function* () {
-    const sessionDescription = new RTCSessionDescription({
-      sdp,
-      type: "answer"
-    });
-    yield pc.setRemoteDescription(sessionDescription);
-  });
-}
-function getLocalDescription(pc) {
-  const desc = pc.localDescription;
-  if (!desc) return void 0;
-  return desc.sdp;
-}
-function waitForIceGathering(pc, timeoutMs = 5e3) {
-  return new Promise((resolve) => {
-    if (pc.iceGatheringState === "complete") {
-      resolve();
-      return;
-    }
-    const onGatheringStateChange = () => {
-      if (pc.iceGatheringState === "complete") {
-        pc.removeEventListener(
-          "icegatheringstatechange",
-          onGatheringStateChange
-        );
-        resolve();
-      }
-    };
-    pc.addEventListener("icegatheringstatechange", onGatheringStateChange);
-    setTimeout(() => {
-      pc.removeEventListener("icegatheringstatechange", onGatheringStateChange);
-      resolve();
-    }, timeoutMs);
-  });
-}
-function sendMessage(channel, command, data) {
-  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 };
-  channel.send(JSON.stringify(payload));
-}
-function parseMessage(data) {
-  if (typeof data === "string") {
-    try {
-      return JSON.parse(data);
-    } catch (e) {
-      return data;
-    }
-  }
-  return data;
-}
-function closePeerConnection(pc) {
-  pc.close();
-}
-
 // src/core/GPUMachineClient.ts
 var GPUMachineClient = class {
   constructor(config) {
     this.eventListeners = /* @__PURE__ */ new Map();
     this.status = "disconnected";
-    this.config = config != null ? config : {};
+    this.config = config;
   }
   // ─────────────────────────────────────────────────────────────────────────────
   // Event Emitter API
@@ -774,13 +895,13 @@ var GPUMachineClient = class {
 };
 
 // src/core/Reactor.ts
-var import_zod = require("zod");
+var import_zod2 = require("zod");
 var LOCAL_COORDINATOR_URL = "http://localhost:8080";
 var PROD_COORDINATOR_URL = "https://api.reactor.inc";
-var OptionsSchema = import_zod.z.object({
-  coordinatorUrl: import_zod.z.string().default(PROD_COORDINATOR_URL),
-  modelName: import_zod.z.string(),
-  local: import_zod.z.boolean().default(false)
+var OptionsSchema = import_zod2.z.object({
+  coordinatorUrl: import_zod2.z.string().default(PROD_COORDINATOR_URL),
+  modelName: import_zod2.z.string(),
+  local: import_zod2.z.boolean().default(false)
 });
 var Reactor = class {
   constructor(options) {
@@ -890,9 +1011,14 @@ var Reactor = class {
         console.warn("[Reactor] No active session to reconnect to.");
         return;
       }
+      if (this.status === "ready") {
+        console.warn("[Reactor] Already connected, no need to reconnect.");
+        return;
+      }
       this.setStatus("connecting");
       if (!this.machineClient) {
-        this.machineClient = new GPUMachineClient();
+        const iceServers = yield this.coordinatorClient.getIceServers();
+        this.machineClient = new GPUMachineClient({ iceServers });
         this.setupMachineClientHandlers();
       }
       const sdpOffer = yield this.machineClient.createOffer();
@@ -904,8 +1030,12 @@ var Reactor = class {
         yield this.machineClient.connect(sdpAnswer);
         this.setStatus("ready");
       } catch (error) {
+        let recoverable = false;
+        if (error instanceof ConflictError) {
+          recoverable = true;
+        }
         console.error("[Reactor] Failed to reconnect:", error);
-        this.disconnect(false);
+        this.disconnect(recoverable);
         this.createError(
           "RECONNECTION_FAILED",
           `Failed to reconnect: ${error}`,
@@ -940,7 +1070,8 @@ var Reactor = class {
           // Safe: validated on line 186-188
           model: this.model
         });
-        this.machineClient = new GPUMachineClient();
+        const iceServers = yield this.coordinatorClient.getIceServers();
+        this.machineClient = new GPUMachineClient({ iceServers });
         this.setupMachineClientHandlers();
         const sdpOffer = yield this.machineClient.createOffer();
         const sessionId = yield this.coordinatorClient.createSession(sdpOffer);
@@ -2152,6 +2283,7 @@ function fetchInsecureJwtToken(_0) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ConflictError,
   PROD_COORDINATOR_URL,
   Reactor,
   ReactorController,