@reactor-team/js-sdk 2.0.2 → 2.2.0

package/dist/index.js

@@ -100,6 +100,155 @@ var ConflictError = class extends Error {
   }
 };
 
+// src/core/types.ts
+var import_zod = require("zod");
+var SessionState = /* @__PURE__ */ ((SessionState2) => {
+  SessionState2[SessionState2["CREATED"] = 0] = "CREATED";
+  SessionState2[SessionState2["PENDING"] = 1] = "PENDING";
+  SessionState2[SessionState2["SUSPENDED"] = 2] = "SUSPENDED";
+  SessionState2[SessionState2["WAITING"] = 3] = "WAITING";
+  SessionState2[SessionState2["ACTIVE"] = 4] = "ACTIVE";
+  SessionState2[SessionState2["INACTIVE"] = 5] = "INACTIVE";
+  SessionState2[SessionState2["CLOSED"] = 6] = "CLOSED";
+  return SessionState2;
+})(SessionState || {});
+var ModelSchema = import_zod.z.object({
+  name: import_zod.z.string()
+});
+var CreateSessionRequestSchema = import_zod.z.object({
+  model: ModelSchema,
+  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;
@@ -118,9 +267,31 @@ 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* () {
-      return [{ urls: "stun:stun.l.google.com:19302" }];
+      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;
     });
   }
   /**
@@ -132,7 +303,7 @@ var CoordinatorClient = class {
     return __async(this, null, function* () {
       console.debug("[CoordinatorClient] Creating session...");
       const requestBody = {
-        model: this.model,
+        model: { name: this.model },
         sdp_offer,
         extra_args: {}
       };
@@ -373,11 +544,13 @@ var LocalCoordinatorClient = class extends CoordinatorClient {
         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:",
-        data.ice_servers
+        iceServers.length
       );
-      return data.ice_servers;
+      return iceServers;
     });
   }
   /**
@@ -440,88 +613,6 @@ var LocalCoordinatorClient = class extends CoordinatorClient {
   }
 };
 
-// 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 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) {
@@ -808,13 +899,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) {