@reactor-team/js-sdk 1.0.18 → 1.0.22

package/dist/index.js

@@ -79,6 +79,7 @@ var __async = (__this, __arguments, generator) => {
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  PROD_COORDINATOR_URL: () => PROD_COORDINATOR_URL,
   Reactor: () => Reactor,
   ReactorController: () => ReactorController,
   ReactorProvider: () => ReactorProvider,
@@ -90,218 +91,603 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/core/types.ts
-var import_zod = require("zod");
-var ApplicationMessageSchema = import_zod.z.object({
-  type: import_zod.z.literal("application"),
-  data: import_zod.z.any()
-  // Can be any JSON-serializable data
-});
-var FPSMessageSchema = import_zod.z.object({
-  type: import_zod.z.literal("fps"),
-  data: import_zod.z.number()
-});
-var GPUMachineReceiveMessageSchema = import_zod.z.discriminatedUnion("type", [
-  ApplicationMessageSchema,
-  FPSMessageSchema
-]);
-var WelcomeMessageSchema = import_zod.z.object({
-  type: import_zod.z.literal("welcome"),
-  data: import_zod.z.record(import_zod.z.string(), import_zod.z.any())
-});
-var GPUMachineAssignmentDataSchema = import_zod.z.object({
-  livekitWsUrl: import_zod.z.string(),
-  livekitJwtToken: import_zod.z.string()
-});
-var GPUMachineAssignmentMessageSchema = import_zod.z.object({
-  type: import_zod.z.literal("gpu-machine-assigned"),
-  data: GPUMachineAssignmentDataSchema
-});
-var EchoMessageSchema = import_zod.z.object({
-  type: import_zod.z.literal("echo"),
-  data: import_zod.z.record(import_zod.z.string(), import_zod.z.any())
-});
-var WaitingInfoDataSchema = import_zod.z.object({
-  position: import_zod.z.number().optional(),
-  estimatedWaitTime: import_zod.z.number().optional(),
-  averageWaitTime: import_zod.z.number().optional()
-});
-var WaitingInfoMessageSchema = import_zod.z.object({
-  type: import_zod.z.literal("waiting-info"),
-  data: WaitingInfoDataSchema
-});
-var SessionExpirationDataSchema = import_zod.z.object({
-  expire: import_zod.z.number()
-});
-var SessionExpirationMessageSchema = import_zod.z.object({
-  type: import_zod.z.literal("session-expiration"),
-  data: SessionExpirationDataSchema
-});
-var CoordinatorMessageSchema = import_zod.z.discriminatedUnion("type", [
-  WelcomeMessageSchema,
-  GPUMachineAssignmentMessageSchema,
-  EchoMessageSchema,
-  WaitingInfoMessageSchema,
-  SessionExpirationMessageSchema
-]);
-var GPUMachineSendMessageSchema = import_zod.z.discriminatedUnion("type", [
-  ApplicationMessageSchema
-]);
-var SessionSetupMessageSchema = import_zod.z.object({
-  type: import_zod.z.literal("sessionSetup"),
-  data: import_zod.z.object({
-    modelName: import_zod.z.string(),
-    modelVersion: import_zod.z.string().default("latest")
-  })
-});
+// src/generated/api/types/api_types.ts
+var import_wire2 = require("@bufbuild/protobuf/wire");
+
+// src/generated/api/types/base.ts
+var import_wire = require("@bufbuild/protobuf/wire");
+
+// src/generated/api/types/api_types.ts
+function createBaseSDPParamsResponse() {
+  return { sdpAnswer: "", extraArgs: {} };
+}
+var SDPParamsResponse = {
+  encode(message, writer = new import_wire2.BinaryWriter()) {
+    if (message.sdpAnswer !== "") {
+      writer.uint32(10).string(message.sdpAnswer);
+    }
+    globalThis.Object.entries(message.extraArgs).forEach(
+      ([key, value]) => {
+        SDPParamsResponse_ExtraArgsEntry.encode(
+          { key, value },
+          writer.uint32(18).fork()
+        ).join();
+      }
+    );
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire2.BinaryReader ? input : new import_wire2.BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseSDPParamsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.sdpAnswer = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          const entry2 = SDPParamsResponse_ExtraArgsEntry.decode(
+            reader,
+            reader.uint32()
+          );
+          if (entry2.value !== void 0) {
+            message.extraArgs[entry2.key] = entry2.value;
+          }
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      sdpAnswer: isSet(object.sdpAnswer) ? globalThis.String(object.sdpAnswer) : "",
+      extraArgs: isObject(object.extraArgs) ? globalThis.Object.entries(object.extraArgs).reduce(
+        (acc, [key, value]) => {
+          acc[key] = globalThis.String(value);
+          return acc;
+        },
+        {}
+      ) : {}
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.sdpAnswer !== "") {
+      obj.sdpAnswer = message.sdpAnswer;
+    }
+    if (message.extraArgs) {
+      const entries = globalThis.Object.entries(message.extraArgs);
+      if (entries.length > 0) {
+        obj.extraArgs = {};
+        entries.forEach(([k, v]) => {
+          obj.extraArgs[k] = v;
+        });
+      }
+    }
+    return obj;
+  },
+  create(base) {
+    return SDPParamsResponse.fromPartial(base != null ? base : {});
+  },
+  fromPartial(object) {
+    var _a, _b;
+    const message = createBaseSDPParamsResponse();
+    message.sdpAnswer = (_a = object.sdpAnswer) != null ? _a : "";
+    message.extraArgs = globalThis.Object.entries((_b = object.extraArgs) != null ? _b : {}).reduce(
+      (acc, [key, value]) => {
+        if (value !== void 0) {
+          acc[key] = globalThis.String(value);
+        }
+        return acc;
+      },
+      {}
+    );
+    return message;
+  }
+};
+function createBaseSDPParamsResponse_ExtraArgsEntry() {
+  return { key: "", value: "" };
+}
+var SDPParamsResponse_ExtraArgsEntry = {
+  encode(message, writer = new import_wire2.BinaryWriter()) {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire2.BinaryReader ? input : new import_wire2.BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseSDPParamsResponse_ExtraArgsEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.key = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.value = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      value: isSet(object.value) ? globalThis.String(object.value) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== "") {
+      obj.value = message.value;
+    }
+    return obj;
+  },
+  create(base) {
+    return SDPParamsResponse_ExtraArgsEntry.fromPartial(base != null ? base : {});
+  },
+  fromPartial(object) {
+    var _a, _b;
+    const message = createBaseSDPParamsResponse_ExtraArgsEntry();
+    message.key = (_a = object.key) != null ? _a : "";
+    message.value = (_b = object.value) != null ? _b : "";
+    return message;
+  }
+};
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function isSet(value) {
+  return value !== null && value !== void 0;
+}
 
 // src/core/CoordinatorClient.ts
-var import_zod2 = require("zod");
-var OptionsSchema = import_zod2.z.object({
-  wsUrl: import_zod2.z.string().nonempty(),
-  jwtToken: import_zod2.z.string().optional(),
-  insecureApiKey: import_zod2.z.string().optional(),
-  modelName: import_zod2.z.string(),
-  modelVersion: import_zod2.z.string().default("latest"),
-  queueing: import_zod2.z.boolean().default(false)
-}).refine((data) => data.jwtToken || data.insecureApiKey, {
-  message: "At least one of jwtToken or insecureApiKey must be provided."
-});
+var INITIAL_BACKOFF_MS = 500;
+var MAX_BACKOFF_MS = 3e4;
+var BACKOFF_MULTIPLIER = 2;
 var CoordinatorClient = class {
   constructor(options) {
-    this.eventListeners = /* @__PURE__ */ new Map();
-    const validatedOptions = OptionsSchema.parse(options);
-    this.wsUrl = validatedOptions.wsUrl;
-    this.jwtToken = validatedOptions.jwtToken;
-    this.insecureApiKey = validatedOptions.insecureApiKey;
-    this.modelName = validatedOptions.modelName;
-    this.modelVersion = validatedOptions.modelVersion;
-    this.queueing = validatedOptions.queueing;
+    this.baseUrl = options.baseUrl;
+    this.jwtToken = options.jwtToken;
+    this.model = options.model;
   }
-  // Event Emitter API
-  on(event, handler) {
-    if (!this.eventListeners.has(event)) {
-      this.eventListeners.set(event, /* @__PURE__ */ new Set());
-    }
-    this.eventListeners.get(event).add(handler);
-  }
-  off(event, handler) {
-    var _a;
-    (_a = this.eventListeners.get(event)) == null ? void 0 : _a.delete(handler);
+  /**
+   * Returns the authorization header with JWT Bearer token
+   */
+  getAuthHeaders() {
+    return {
+      Authorization: `Bearer ${this.jwtToken}`
+    };
   }
-  emit(event, ...args) {
-    var _a;
-    (_a = this.eventListeners.get(event)) == null ? void 0 : _a.forEach((handler) => handler(...args));
+  /**
+   * Creates a new session with the coordinator.
+   * Expects a 200 response and stores the session ID.
+   * @returns The session ID
+   */
+  createSession(sdp_offer) {
+    return __async(this, null, function* () {
+      console.debug("[CoordinatorClient] Creating session...");
+      const requestBody = {
+        model: this.model,
+        sdp_offer,
+        extra_args: {}
+      };
+      const response = yield fetch(`${this.baseUrl}/sessions`, {
+        method: "POST",
+        headers: __spreadProps(__spreadValues({}, this.getAuthHeaders()), {
+          "Content-Type": "application/json"
+        }),
+        body: JSON.stringify(requestBody)
+      });
+      if (response.status !== 200) {
+        const errorText = yield response.text();
+        throw new Error(
+          `Failed to create session: ${response.status} ${errorText}`
+        );
+      }
+      const data = yield response.json();
+      this.currentSessionId = data.session_id;
+      console.debug(
+        "[CoordinatorClient] Session created with ID:",
+        this.currentSessionId
+      );
+      return data.session_id;
+    });
   }
-  sendMessage(message) {
-    var _a;
-    try {
-      const messageStr = typeof message === "string" ? message : JSON.stringify(message);
-      (_a = this.websocket) == null ? void 0 : _a.send(messageStr);
-    } catch (error) {
-      console.error("[CoordinatorClient] Failed to send message:", error);
-      this.emit("statusChanged", "error");
-    }
+  /**
+   * Gets the current session information from the coordinator.
+   * @returns The session data (untyped for now)
+   */
+  getSession() {
+    return __async(this, null, function* () {
+      if (!this.currentSessionId) {
+        throw new Error("No active session. Call createSession() first.");
+      }
+      console.debug(
+        "[CoordinatorClient] Getting session info for:",
+        this.currentSessionId
+      );
+      const response = yield fetch(
+        `${this.baseUrl}/sessions/${this.currentSessionId}`,
+        {
+          method: "GET",
+          headers: this.getAuthHeaders()
+        }
+      );
+      if (response.status !== 200) {
+        const errorText = yield response.text();
+        throw new Error(`Failed to get session: ${response.status} ${errorText}`);
+      }
+      const data = yield response.json();
+      return data;
+    });
   }
-  connect() {
+  /**
+   * Terminates the current session by sending a DELETE request to the coordinator.
+   * @throws Error if no active session exists or if the request fails (except for 404)
+   */
+  terminateSession() {
     return __async(this, null, function* () {
-      const url = new URL(this.wsUrl);
-      if (this.jwtToken) {
-        url.searchParams.set("jwt_token", this.jwtToken);
-      } else if (this.insecureApiKey) {
-        url.searchParams.set("api_key", this.insecureApiKey);
+      if (!this.currentSessionId) {
+        throw new Error("No active session. Call createSession() first.");
       }
-      if (this.queueing) {
-        url.searchParams.set("queueing", "true");
+      console.debug(
+        "[CoordinatorClient] Terminating session:",
+        this.currentSessionId
+      );
+      const response = yield fetch(
+        `${this.baseUrl}/sessions/${this.currentSessionId}`,
+        {
+          method: "DELETE",
+          headers: this.getAuthHeaders()
+        }
+      );
+      if (response.status === 200 || response.status === 204) {
+        const data = yield response.json();
+        console.debug(
+          "[CoordinatorClient] Session terminated:",
+          data.session_id,
+          data.status
+        );
+        this.currentSessionId = void 0;
+        return;
+      }
+      if (response.status === 404) {
+        console.debug(
+          "[CoordinatorClient] Session not found on server, clearing local state:",
+          this.currentSessionId
+        );
+        this.currentSessionId = void 0;
+        return;
       }
-      console.debug("[CoordinatorClient] Connecting to", url.toString());
-      this.websocket = new WebSocket(url.toString());
-      this.websocket.onopen = () => {
-        console.debug("[CoordinatorClient] WebSocket opened");
-        this.emit("statusChanged", "connected");
+      const errorText = yield response.text();
+      throw new Error(
+        `Failed to terminate session: ${response.status} ${errorText}`
+      );
+    });
+  }
+  /**
+   * Get the current session ID
+   */
+  getSessionId() {
+    return this.currentSessionId;
+  }
+  /**
+   * Sends an SDP offer to the server for reconnection.
+   * @param sessionId - The session ID to connect to
+   * @param sdpOffer - The SDP offer from the local WebRTC peer connection
+   * @returns The SDP answer if ready (200), or null if pending (202)
+   */
+  sendSdpOffer(sessionId, sdpOffer) {
+    return __async(this, null, function* () {
+      console.debug(
+        "[CoordinatorClient] Sending SDP offer for session:",
+        sessionId
+      );
+      const requestBody = {
+        sdp_offer: sdpOffer,
+        extra_args: {}
       };
-      this.websocket.onmessage = (event) => {
-        try {
-          let parsedData;
-          if (typeof event.data === "string") {
-            parsedData = JSON.parse(event.data);
-          } else {
-            parsedData = event.data;
+      const response = yield fetch(
+        `${this.baseUrl}/sessions/${sessionId}/sdp_params`,
+        {
+          method: "PUT",
+          headers: __spreadProps(__spreadValues({}, this.getAuthHeaders()), {
+            "Content-Type": "application/json"
+          }),
+          body: JSON.stringify(requestBody)
+        }
+      );
+      if (response.status === 200) {
+        const answerData = yield response.json();
+        console.debug("[CoordinatorClient] Received SDP answer immediately");
+        return answerData.sdp_answer;
+      }
+      if (response.status === 202) {
+        console.debug(
+          "[CoordinatorClient] SDP offer accepted, answer pending (202)"
+        );
+        return null;
+      }
+      const errorText = yield response.text();
+      throw new Error(
+        `Failed to send SDP offer: ${response.status} ${errorText}`
+      );
+    });
+  }
+  /**
+   * Polls for the SDP answer with geometric backoff.
+   * Used for async reconnection when the answer is not immediately available.
+   * @param sessionId - The session ID to poll for
+   * @returns The SDP answer from the server
+   */
+  pollSdpAnswer(sessionId) {
+    return __async(this, null, function* () {
+      console.debug(
+        "[CoordinatorClient] Polling for SDP answer for session:",
+        sessionId
+      );
+      let backoffMs = INITIAL_BACKOFF_MS;
+      let attempt = 0;
+      while (true) {
+        attempt++;
+        console.debug(
+          `[CoordinatorClient] SDP poll attempt ${attempt} for session ${sessionId}`
+        );
+        const response = yield fetch(
+          `${this.baseUrl}/sessions/${sessionId}/sdp_params`,
+          {
+            method: "GET",
+            headers: __spreadProps(__spreadValues({}, this.getAuthHeaders()), {
+              "Content-Type": "application/json"
+            })
           }
-          console.debug(
-            "[CoordinatorClient] Received message from coordinator:",
-            parsedData
+        );
+        if (response.status === 200) {
+          const answerData = SDPParamsResponse.fromJSON(
+            yield response.json()
           );
-          const validatedData = CoordinatorMessageSchema.parse(parsedData);
-          this.emit(validatedData.type, validatedData.data);
-        } catch (error) {
-          console.error(
-            "[CoordinatorClient] Failed to parse WebSocket message from coordinator:",
-            error,
-            "message",
-            event.data
+          console.debug("[CoordinatorClient] Received SDP answer via polling");
+          return answerData.sdp_answer;
+        }
+        if (response.status === 202) {
+          console.warn(
+            `[CoordinatorClient] SDP answer pending (202), retrying in ${backoffMs}ms...`
           );
-          this.emit("statusChanged", "error");
+          yield this.sleep(backoffMs);
+          backoffMs = Math.min(backoffMs * BACKOFF_MULTIPLIER, MAX_BACKOFF_MS);
+          continue;
         }
-      };
-      this.websocket.onclose = (event) => {
-        console.debug("[CoordinatorClient] WebSocket closed", event);
-        this.websocket = void 0;
-        this.emit("statusChanged", "disconnected");
-      };
-      this.websocket.onerror = (error) => {
-        console.error("[CoordinatorClient] WebSocket error:", error);
-        this.websocket = void 0;
-        this.emit("statusChanged", "error");
-      };
-      yield new Promise((resolve, reject) => {
-        var _a, _b;
-        const onOpen = () => {
-          var _a2;
-          (_a2 = this.websocket) == null ? void 0 : _a2.removeEventListener("error", onError);
-          resolve();
-        };
-        const onError = (error) => {
-          var _a2;
-          (_a2 = this.websocket) == null ? void 0 : _a2.removeEventListener("open", onOpen);
-          reject(error);
-        };
-        (_a = this.websocket) == null ? void 0 : _a.addEventListener("open", onOpen);
-        (_b = this.websocket) == null ? void 0 : _b.addEventListener("error", onError);
-      });
-      console.log("[CoordinatorClient] WebSocket connected");
-      this.sendMessage({
-        type: "sessionSetup",
-        data: {
-          modelName: this.modelName,
-          modelVersion: this.modelVersion
+        const errorText = yield response.text();
+        throw new Error(
+          `Failed to poll SDP answer: ${response.status} ${errorText}`
+        );
+      }
+    });
+  }
+  /**
+   * Connects to the session by sending an SDP offer and receiving an SDP answer.
+   * If sdpOffer is provided, sends it first. If the answer is pending (202),
+   * 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
+   * @returns The SDP answer from the server
+   */
+  connect(sessionId, sdpOffer) {
+    return __async(this, null, function* () {
+      console.debug("[CoordinatorClient] Connecting to session:", sessionId);
+      if (sdpOffer) {
+        const answer = yield this.sendSdpOffer(sessionId, sdpOffer);
+        if (answer !== null) {
+          return answer;
         }
+      }
+      return this.pollSdpAnswer(sessionId);
+    });
+  }
+  /**
+   * Utility function to sleep for a given number of milliseconds
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/core/LocalCoordinatorClient.ts
+var LocalCoordinatorClient = class extends CoordinatorClient {
+  constructor(baseUrl) {
+    super({
+      baseUrl,
+      jwtToken: "local",
+      model: "local"
+    });
+    this.localBaseUrl = baseUrl;
+  }
+  /**
+   * Creates a local session by posting to /start_session.
+   * @returns always "local"
+   */
+  createSession(sdpOffer) {
+    return __async(this, null, function* () {
+      console.debug("[LocalCoordinatorClient] Creating local session...");
+      this.sdpOffer = sdpOffer;
+      const response = yield fetch(`${this.localBaseUrl}/start_session`, {
+        method: "POST"
       });
-      console.debug("[CoordinatorClient] Setup session message sent");
+      if (!response.ok) {
+        throw new Error("Failed to send local start session command.");
+      }
+      console.debug("[LocalCoordinatorClient] Local session created");
+      return "local";
     });
   }
   /**
-   * Closes the WebSocket connection if it exists.
-   * This will trigger the onclose event handler.
+   * Connects to the local session by posting SDP params to /sdp_params.
+   * @param sessionId - The session ID (ignored for local)
+   * @param sdpMessage - The SDP offer from the local WebRTC peer connection
+   * @returns The SDP answer from the server
    */
-  disconnect() {
-    if (this.websocket) {
-      console.debug("[CoordinatorClient] Closing WebSocket connection");
-      this.websocket.close();
-      this.websocket = void 0;
-    }
+  connect(sessionId, sdpMessage) {
+    return __async(this, null, function* () {
+      this.sdpOffer = sdpMessage || this.sdpOffer;
+      console.debug("[LocalCoordinatorClient] Connecting to local session...");
+      const sdpBody = {
+        sdp: this.sdpOffer,
+        type: "offer"
+      };
+      const response = yield fetch(`${this.localBaseUrl}/sdp_params`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(sdpBody)
+      });
+      if (!response.ok) {
+        throw new Error("Failed to get SDP answer from local coordinator.");
+      }
+      const sdpAnswer = yield response.json();
+      console.debug("[LocalCoordinatorClient] Received SDP answer");
+      return sdpAnswer.sdp;
+    });
+  }
+  terminateSession() {
+    return __async(this, null, function* () {
+      console.debug("[LocalCoordinatorClient] Stopping local session...");
+      yield fetch(`${this.localBaseUrl}/stop_session`, {
+        method: "POST"
+      });
+    });
   }
 };
 
+// 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 import_livekit_client = require("livekit-client");
 var GPUMachineClient = class {
-  constructor(token, liveKitUrl) {
+  constructor(config) {
     this.eventListeners = /* @__PURE__ */ new Map();
-    this.token = token;
-    this.liveKitUrl = liveKitUrl;
+    this.status = "disconnected";
+    this.config = config != null ? config : {};
   }
+  // ─────────────────────────────────────────────────────────────────────────────
   // Event Emitter API
+  // ─────────────────────────────────────────────────────────────────────────────
   on(event, handler) {
     if (!this.eventListeners.has(event)) {
       this.eventListeners.set(event, /* @__PURE__ */ new Set());
@@ -316,294 +702,287 @@ var GPUMachineClient = class {
     var _a;
     (_a = this.eventListeners.get(event)) == null ? void 0 : _a.forEach((handler) => handler(...args));
   }
-  sendMessage(message) {
+  // ─────────────────────────────────────────────────────────────────────────────
+  // SDP & Connection
+  // ─────────────────────────────────────────────────────────────────────────────
+  /**
+   * Creates an SDP offer for initiating a connection.
+   * Must be called before connect().
+   */
+  createOffer() {
     return __async(this, null, function* () {
-      try {
-        if (this.roomInstance) {
-          const messageStr = JSON.stringify(message);
-          yield this.roomInstance.localParticipant.sendText(messageStr, {
-            topic: "application"
-          });
-        } else {
-          console.warn(
-            "[GPUMachineClient] Cannot send message - not connected to room"
-          );
-        }
-      } catch (error) {
-        console.error("[GPUMachineClient] Failed to send message:", error);
-        this.emit("statusChanged", "error");
+      if (!this.peerConnection) {
+        this.peerConnection = createPeerConnection(this.config);
+        this.setupPeerConnectionHandlers();
       }
+      this.dataChannel = createDataChannel(
+        this.peerConnection,
+        this.config.dataChannelLabel
+      );
+      this.setupDataChannelHandlers();
+      this.videoTransceiver = this.peerConnection.addTransceiver("video", {
+        direction: "sendrecv"
+      });
+      const offer = yield createOffer(this.peerConnection);
+      console.debug("[GPUMachineClient] Created SDP offer");
+      return offer;
     });
   }
-  connect() {
+  /**
+   * Connects to the GPU machine using the provided SDP answer.
+   * createOffer() must be called first.
+   * @param sdpAnswer The SDP answer from the GPU machine
+   */
+  connect(sdpAnswer) {
     return __async(this, null, function* () {
-      this.roomInstance = new import_livekit_client.Room({
-        adaptiveStream: true,
-        dynacast: true
-      });
-      this.roomInstance.on(import_livekit_client.RoomEvent.Connected, () => {
-        console.debug("[GPUMachineClient] Connected to room");
-        this.emit("statusChanged", "connected");
-      });
-      this.roomInstance.on(import_livekit_client.RoomEvent.Disconnected, () => {
-        console.debug("[GPUMachineClient] Disconnected from room");
-        this.emit("statusChanged", "disconnected");
-      });
-      this.roomInstance.on(
-        import_livekit_client.RoomEvent.TrackSubscribed,
-        (track, _publication, participant) => {
-          console.debug(
-            "[GPUMachineClient] Track subscribed:",
-            track.kind,
-            participant.identity
-          );
-          if (track.kind === import_livekit_client.Track.Kind.Video) {
-            const videoTrack = track;
-            this.emit("streamChanged", videoTrack);
-          }
-        }
-      );
-      this.roomInstance.on(
-        import_livekit_client.RoomEvent.TrackUnsubscribed,
-        (track, _publication, participant) => {
-          console.debug(
-            "[GPUMachineClient] Track unsubscribed:",
-            track.kind,
-            participant.identity
-          );
-          if (track.kind === import_livekit_client.Track.Kind.Video) {
-            this.emit("streamChanged", null);
-          }
-        }
-      );
-      this.roomInstance.registerTextStreamHandler(
-        "application",
-        (reader, participant) => __async(this, null, function* () {
-          const text = yield reader.readAll();
-          console.log("[GPUMachineClient] Received message:", text);
-          try {
-            const parsedData = JSON.parse(text);
-            const validatedMessage = GPUMachineReceiveMessageSchema.parse(parsedData);
-            if (validatedMessage.type === "fps") {
-              this.machineFPS = validatedMessage.data;
-            }
-            this.emit(validatedMessage.type, validatedMessage.data);
-          } catch (error) {
-            console.error(
-              "[GPUMachineClient] Failed to parse/validate message:",
-              error
-            );
-            this.emit("statusChanged", "error");
-          }
-        })
-      );
-      yield this.roomInstance.connect(this.liveKitUrl, this.token);
-      console.log("[GPUMachineClient] Room connected");
+      if (!this.peerConnection) {
+        throw new Error(
+          "[GPUMachineClient] Cannot connect - call createOffer() first"
+        );
+      }
+      if (this.peerConnection.signalingState !== "have-local-offer") {
+        throw new Error(
+          `[GPUMachineClient] Invalid signaling state: ${this.peerConnection.signalingState}`
+        );
+      }
+      this.setStatus("connecting");
+      try {
+        yield setRemoteDescription(this.peerConnection, sdpAnswer);
+        console.debug("[GPUMachineClient] Remote description set");
+      } catch (error) {
+        console.error("[GPUMachineClient] Failed to connect:", error);
+        this.setStatus("error");
+        throw error;
+      }
     });
   }
   /**
-   * Closes the LiveKit connection if it exists.
-   * This will trigger the onclose event handler.
+   * Disconnects from the GPU machine and cleans up resources.
    */
   disconnect() {
     return __async(this, null, function* () {
-      if (this.publishedVideoTrack) {
-        yield this.unpublishVideoTrack();
+      if (this.publishedTrack) {
+        yield this.unpublishTrack();
       }
-      if (this.publishedAudioTrack) {
-        yield this.unpublishAudioTrack();
+      if (this.dataChannel) {
+        this.dataChannel.close();
+        this.dataChannel = void 0;
       }
-      if (this.roomInstance) {
-        console.debug("[GPUMachineClient] Closing LiveKit connection");
-        yield this.roomInstance.disconnect();
-        this.roomInstance = void 0;
+      if (this.peerConnection) {
+        closePeerConnection(this.peerConnection);
+        this.peerConnection = void 0;
       }
-      this.machineFPS = void 0;
+      this.videoTransceiver = void 0;
+      this.setStatus("disconnected");
+      console.debug("[GPUMachineClient] Disconnected");
     });
   }
   /**
-   * Returns the current fps rate of the machine.
-   * @returns The current fps rate of the machine.
+   * Returns the current connection status.
+   */
+  getStatus() {
+    return this.status;
+  }
+  /**
+   * Gets the current local SDP description.
    */
-  getFPS() {
-    return this.machineFPS;
+  getLocalSDP() {
+    if (!this.peerConnection) return void 0;
+    return getLocalDescription(this.peerConnection);
   }
+  isOfferStillValid() {
+    if (!this.peerConnection) return false;
+    return this.peerConnection.signalingState === "have-local-offer";
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Messaging
+  // ─────────────────────────────────────────────────────────────────────────────
   /**
-   * Returns the current video stream from the GPU machine.
-   * @returns The current video stream or undefined if not available.
+   * 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.
    */
-  getVideoStream() {
-    return this.videoStream;
+  sendCommand(command, data) {
+    if (!this.dataChannel) {
+      throw new Error("[GPUMachineClient] Data channel not available");
+    }
+    try {
+      sendMessage(this.dataChannel, command, data);
+    } catch (error) {
+      console.warn("[GPUMachineClient] Failed to send message:", error);
+    }
   }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Track Publishing
+  // ─────────────────────────────────────────────────────────────────────────────
   /**
-   * Publishes a video track from the provided MediaStream to the LiveKit room.
-   * Only one video track can be published at a time. If a video track is already
-   * published, it will be unpublished first.
-   *
-   * @param mediaStream The MediaStream containing the video track to publish
-   * @throws Error if no video track is found in the MediaStream or room is not connected
+   * Publishes a track to the GPU machine.
+   * Only one track can be published at a time.
+   * Uses the existing transceiver's sender to replace the track.
+   * @param track The MediaStreamTrack to publish
    */
-  publishVideoTrack(mediaStream) {
+  publishTrack(track) {
     return __async(this, null, function* () {
-      if (!this.roomInstance) {
+      if (!this.peerConnection) {
         throw new Error(
-          "[GPUMachineClient] Cannot publish track - not connected to room"
+          "[GPUMachineClient] Cannot publish track - not initialized"
         );
       }
-      const videoTracks = mediaStream.getVideoTracks();
-      if (videoTracks.length === 0) {
-        throw new Error("[GPUMachineClient] No video track found in MediaStream");
+      if (this.status !== "connected") {
+        throw new Error(
+          "[GPUMachineClient] Cannot publish track - not connected"
+        );
       }
-      if (this.publishedVideoTrack) {
-        yield this.unpublishVideoTrack();
+      if (!this.videoTransceiver) {
+        throw new Error(
+          "[GPUMachineClient] Cannot publish track - no video transceiver"
+        );
       }
       try {
-        const videoTrack = videoTracks[0];
-        const localVideoTrack = yield this.roomInstance.localParticipant.publishTrack(videoTrack, {
-          name: "client-video",
-          source: import_livekit_client.Track.Source.Camera
-        });
-        this.publishedVideoTrack = localVideoTrack.track;
-        console.debug("[GPUMachineClient] Video track published successfully");
+        yield this.videoTransceiver.sender.replaceTrack(track);
+        this.publishedTrack = track;
+        console.debug(
+          "[GPUMachineClient] Track published successfully:",
+          track.kind
+        );
       } catch (error) {
-        console.error("[GPUMachineClient] Failed to publish video track:", error);
+        console.error("[GPUMachineClient] Failed to publish track:", error);
         throw error;
       }
     });
   }
   /**
-   * Unpublishes the currently published video track.
-   * Note: We pass false to unpublishTrack to prevent LiveKit from stopping
-   * the source MediaStreamTrack, as it's owned by the component that created it.
+   * Unpublishes the currently published track.
    */
-  unpublishVideoTrack() {
+  unpublishTrack() {
     return __async(this, null, function* () {
-      if (!this.roomInstance || !this.publishedVideoTrack) {
-        return;
-      }
-      const publishedVideoTrack = this.publishedVideoTrack;
-      this.publishedVideoTrack = void 0;
+      if (!this.videoTransceiver || !this.publishedTrack) return;
       try {
-        yield this.roomInstance.localParticipant.unpublishTrack(
-          publishedVideoTrack,
-          false
-          // Don't stop the source track - it's managed externally
-        );
-        console.debug("[GPUMachineClient] Video track unpublished successfully");
+        yield this.videoTransceiver.sender.replaceTrack(null);
+        console.debug("[GPUMachineClient] Track unpublished successfully");
       } catch (error) {
-        console.error(
-          "[GPUMachineClient] Failed to unpublish video track:",
-          error
-        );
+        console.error("[GPUMachineClient] Failed to unpublish track:", error);
         throw error;
+      } finally {
+        this.publishedTrack = void 0;
       }
     });
   }
   /**
-   * Publishes an audio track from the provided MediaStream to the LiveKit room.
-   * This is an internal method. Only one audio track can be published at a time.
-   *
-   * @param mediaStream The MediaStream containing the audio track to publish
-   * @private
+   * Returns the currently published track.
    */
-  publishAudioTrack(mediaStream) {
-    return __async(this, null, function* () {
-      if (!this.roomInstance) {
-        throw new Error(
-          "[GPUMachineClient] Cannot publish track - not connected to room"
-        );
-      }
-      const audioTracks = mediaStream.getAudioTracks();
-      if (audioTracks.length === 0) {
-        throw new Error("[GPUMachineClient] No audio track found in MediaStream");
-      }
-      if (this.publishedAudioTrack) {
-        yield this.unpublishAudioTrack();
-      }
-      try {
-        const audioTrack = audioTracks[0];
-        const localAudioTrack = yield this.roomInstance.localParticipant.publishTrack(audioTrack, {
-          name: "client-audio",
-          source: import_livekit_client.Track.Source.Microphone
-        });
-        this.publishedAudioTrack = localAudioTrack.track;
-        console.debug("[GPUMachineClient] Audio track published successfully");
-      } catch (error) {
-        console.error("[GPUMachineClient] Failed to publish audio track:", error);
-        throw error;
-      }
-    });
+  getPublishedTrack() {
+    return this.publishedTrack;
   }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Getters
+  // ─────────────────────────────────────────────────────────────────────────────
   /**
-   * Unpublishes the currently published audio track.
-   * Note: We pass false to unpublishTrack to prevent LiveKit from stopping
-   * the source MediaStreamTrack, as it's owned by the component that created it.
-   * @private
+   * Returns the remote media stream from the GPU machine.
    */
-  unpublishAudioTrack() {
-    return __async(this, null, function* () {
-      if (!this.roomInstance || !this.publishedAudioTrack) {
-        return;
+  getRemoteStream() {
+    if (!this.peerConnection) return void 0;
+    const receivers = this.peerConnection.getReceivers();
+    const tracks = receivers.map((r) => r.track).filter((t) => t !== null);
+    if (tracks.length === 0) return void 0;
+    return new MediaStream(tracks);
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Private Helpers
+  // ─────────────────────────────────────────────────────────────────────────────
+  setStatus(newStatus) {
+    if (this.status !== newStatus) {
+      this.status = newStatus;
+      this.emit("statusChanged", newStatus);
+    }
+  }
+  setupPeerConnectionHandlers() {
+    if (!this.peerConnection) return;
+    this.peerConnection.onconnectionstatechange = () => {
+      var _a;
+      const state = (_a = this.peerConnection) == null ? void 0 : _a.connectionState;
+      console.debug("[GPUMachineClient] Connection state:", state);
+      if (state) {
+        switch (state) {
+          case "connected":
+            this.setStatus("connected");
+            break;
+          case "disconnected":
+          case "closed":
+            this.setStatus("disconnected");
+            break;
+          case "failed":
+            this.setStatus("error");
+            break;
+        }
       }
-      const publishedAudioTrack = this.publishedAudioTrack;
-      this.publishedAudioTrack = void 0;
+    };
+    this.peerConnection.ontrack = (event) => {
+      var _a;
+      console.debug("[GPUMachineClient] Track received:", event.track.kind);
+      const stream = (_a = event.streams[0]) != null ? _a : new MediaStream([event.track]);
+      this.emit("trackReceived", event.track, stream);
+    };
+    this.peerConnection.onicecandidate = (event) => {
+      if (event.candidate) {
+        console.debug("[GPUMachineClient] ICE candidate:", event.candidate);
+      }
+    };
+    this.peerConnection.onicecandidateerror = (event) => {
+      console.warn("[GPUMachineClient] ICE candidate error:", event);
+    };
+    this.peerConnection.ondatachannel = (event) => {
+      console.debug("[GPUMachineClient] Data channel received from remote");
+      this.dataChannel = event.channel;
+      this.setupDataChannelHandlers();
+    };
+  }
+  setupDataChannelHandlers() {
+    if (!this.dataChannel) return;
+    this.dataChannel.onopen = () => {
+      console.debug("[GPUMachineClient] Data channel open");
+    };
+    this.dataChannel.onclose = () => {
+      console.debug("[GPUMachineClient] Data channel closed");
+    };
+    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);
       try {
-        yield this.roomInstance.localParticipant.unpublishTrack(
-          publishedAudioTrack,
-          false
-          // Don't stop the source track - it's managed externally
-        );
-        console.debug("[GPUMachineClient] Audio track unpublished successfully");
+        this.emit("application", data);
       } catch (error) {
         console.error(
-          "[GPUMachineClient] Failed to unpublish audio track:",
+          "[GPUMachineClient] Failed to parse/validate message:",
           error
         );
-        throw error;
       }
-    });
+    };
   }
 };
 
 // src/core/Reactor.ts
-var import_zod3 = require("zod");
-var LOCAL_COORDINATOR_URL = "ws://localhost:8080/ws";
-var LOCAL_INSECURE_API_KEY = "1234";
-var PROD_COORDINATOR_URL = "wss://api.reactor.inc/ws";
-var OptionsSchema2 = import_zod3.z.object({
-  directConnection: import_zod3.z.object({
-    livekitJwtToken: import_zod3.z.string(),
-    livekitWsUrl: import_zod3.z.string()
-  }).optional(),
-  insecureApiKey: import_zod3.z.string().optional(),
-  jwtToken: import_zod3.z.string().optional(),
-  coordinatorUrl: import_zod3.z.string().default(PROD_COORDINATOR_URL),
-  modelName: import_zod3.z.string(),
-  queueing: import_zod3.z.boolean().default(false),
-  local: import_zod3.z.boolean().default(false)
-}).refine(
-  (data) => data.directConnection || data.insecureApiKey || data.jwtToken || data.local,
-  {
-    message: "At least one of directConnection, insecureApiKey, or jwtToken or local must be provided."
-  }
-);
+var import_zod = 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 Reactor = class {
   constructor(options) {
-    //client for the machine instance
     this.status = "disconnected";
     // Generic event map
     this.eventListeners = /* @__PURE__ */ new Map();
-    const validatedOptions = OptionsSchema2.parse(options);
+    const validatedOptions = OptionsSchema.parse(options);
     this.coordinatorUrl = validatedOptions.coordinatorUrl;
-    this.jwtToken = validatedOptions.jwtToken;
-    this.insecureApiKey = validatedOptions.insecureApiKey;
-    this.directConnection = validatedOptions.directConnection;
-    this.modelName = validatedOptions.modelName;
-    this.queueing = validatedOptions.queueing;
-    this.modelVersion = "1.0.0";
-    if (validatedOptions.local) {
+    this.model = validatedOptions.modelName;
+    this.local = validatedOptions.local;
+    if (this.local) {
       this.coordinatorUrl = LOCAL_COORDINATOR_URL;
-      this.insecureApiKey = LOCAL_INSECURE_API_KEY;
     }
   }
   // Event Emitter API
@@ -627,20 +1006,16 @@ var Reactor = class {
    * @param message The message to send to the machine.
    * @throws Error if not in ready state
    */
-  sendMessage(message) {
+  sendCommand(command, data) {
     return __async(this, null, function* () {
       var _a;
       if (process.env.NODE_ENV !== "development" && this.status !== "ready") {
         const errorMessage = `Cannot send message, status is ${this.status}`;
-        console.error("[Reactor] Not ready, cannot send message");
-        throw new Error(errorMessage);
+        console.warn("[Reactor]", errorMessage);
+        return;
       }
       try {
-        const applicationMessage = {
-          type: "application",
-          data: message
-        };
-        yield (_a = this.machineClient) == null ? void 0 : _a.sendMessage(applicationMessage);
+        (_a = this.machineClient) == null ? void 0 : _a.sendCommand(command, data);
       } catch (error) {
         console.error("[Reactor] Failed to send message:", error);
         this.createError(
@@ -653,24 +1028,24 @@ var Reactor = class {
     });
   }
   /**
-   * Public method to publish a video stream to the machine.
-   * @param videoStream The video stream to send to the machine.
+   * Public method to publish a track to the machine.
+   * @param track The track to send to the machine.
    */
-  publishVideoStream(videoStream) {
+  publishTrack(track) {
     return __async(this, null, function* () {
       var _a;
       if (process.env.NODE_ENV !== "development" && this.status !== "ready") {
-        const errorMessage = `Cannot publish video stream, status is ${this.status}`;
-        console.error("[Reactor] Not ready, cannot publish video stream");
-        throw new Error(errorMessage);
+        const errorMessage = `Cannot publish track, status is ${this.status}`;
+        console.warn("[Reactor]", errorMessage);
+        return;
       }
       try {
-        yield (_a = this.machineClient) == null ? void 0 : _a.publishVideoTrack(videoStream);
+        yield (_a = this.machineClient) == null ? void 0 : _a.publishTrack(track);
       } catch (error) {
-        console.error("[Reactor] Failed to publish video:", error);
+        console.error("[Reactor] Failed to publish track:", error);
         this.createError(
-          "VIDEO_PUBLISH_FAILED",
-          `Failed to publish video: ${error}`,
+          "TRACK_PUBLISH_FAILED",
+          `Failed to publish track: ${error}`,
           "gpu",
           true
         );
@@ -678,19 +1053,18 @@ var Reactor = class {
     });
   }
   /**
-   * Public method to unpublish video stream to the machine.
-   * This unpublishes the video track that was previously sent.
+   * Public method to unpublish the currently published track.
    */
-  unpublishVideoStream() {
+  unpublishTrack() {
     return __async(this, null, function* () {
       var _a;
       try {
-        yield (_a = this.machineClient) == null ? void 0 : _a.unpublishVideoTrack();
+        yield (_a = this.machineClient) == null ? void 0 : _a.unpublishTrack();
       } catch (error) {
-        console.error("[Reactor] Failed to unpublish video:", error);
+        console.error("[Reactor] Failed to unpublish track:", error);
         this.createError(
-          "VIDEO_UNPUBLISH_FAILED",
-          `Failed to unpublish video: ${error}`,
+          "TRACK_UNPUBLISH_FAILED",
+          `Failed to unpublish track: ${error}`,
           "gpu",
           true
         );
@@ -698,152 +1072,76 @@ var Reactor = class {
     });
   }
   /**
-   * Connects to the machine via LiveKit and waits for the gpu machine to be ready.
-   * Once the machine is ready, the Reactor will establish the LiveKit connection.
-   * @param livekitJwtToken The JWT token for LiveKit authentication
-   * @param livekitWsUrl The WebSocket URL for LiveKit connection
+   * Public method for reconnecting to an existing session, that may have been interrupted but can be recovered.
    */
-  connectToGPUMachine(livekitJwtToken, livekitWsUrl) {
+  reconnect() {
     return __async(this, null, function* () {
-      console.debug("[Reactor] Connecting to machine room...");
+      if (!this.sessionId || !this.coordinatorClient) {
+        console.warn("[Reactor] No active session to reconnect to.");
+        return;
+      }
+      this.setStatus("connecting");
+      if (!this.machineClient) {
+        this.machineClient = new GPUMachineClient();
+        this.setupMachineClientHandlers();
+      }
+      const sdpOffer = yield this.machineClient.createOffer();
       try {
-        this.machineClient = new GPUMachineClient(livekitJwtToken, livekitWsUrl);
-        this.machineClient.on("application", (message) => {
-          this.emit("newMessage", message);
-        });
-        this.machineClient.on(
-          "statusChanged",
-          (status) => {
-            switch (status) {
-              case "connected":
-                this.setStatus("ready");
-                break;
-              case "disconnected":
-                this.disconnect();
-                break;
-              case "error":
-                this.createError(
-                  "GPU_CONNECTION_ERROR",
-                  "GPU machine connection failed",
-                  "gpu",
-                  true
-                );
-                this.disconnect();
-                break;
-            }
-          }
+        const sdpAnswer = yield this.coordinatorClient.connect(
+          this.sessionId,
+          sdpOffer
         );
-        this.machineClient.on("fps", (fps) => {
-          this.emit("fps", fps);
-        });
-        this.machineClient.on("streamChanged", (videoTrack) => {
-          this.emit("streamChanged", videoTrack);
-        });
-        console.debug("[Reactor] About to connect to machine");
-        yield this.machineClient.connect();
+        yield this.machineClient.connect(sdpAnswer);
+        this.setStatus("ready");
       } catch (error) {
-        throw error;
+        console.error("[Reactor] Failed to reconnect:", error);
+        this.disconnect(false);
+        this.createError(
+          "RECONNECTION_FAILED",
+          `Failed to reconnect: ${error}`,
+          "coordinator",
+          true
+        );
       }
     });
   }
   /**
    * 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 LiveKit.
+   * 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.
    */
-  connect() {
+  connect(jwtToken) {
     return __async(this, null, function* () {
       console.debug("[Reactor] Connecting, status:", this.status);
-      if (this.status !== "disconnected")
+      if (jwtToken == void 0 && !this.local) {
+        throw new Error("No authentication provided and not in local mode");
+      }
+      if (this.status !== "disconnected") {
         throw new Error("Already connected or connecting");
-      if (this.directConnection) {
-        return this.connectToGPUMachine(
-          this.directConnection.livekitJwtToken,
-          this.directConnection.livekitWsUrl
-        );
       }
       this.setStatus("connecting");
       try {
         console.debug(
           "[Reactor] Connecting to coordinator with authenticated URL"
         );
-        this.coordinatorClient = new CoordinatorClient({
-          wsUrl: this.coordinatorUrl,
-          jwtToken: this.jwtToken,
-          insecureApiKey: this.insecureApiKey,
-          modelName: this.modelName,
-          modelVersion: this.modelVersion,
-          queueing: this.queueing
+        this.coordinatorClient = this.local ? new LocalCoordinatorClient(this.coordinatorUrl) : new CoordinatorClient({
+          baseUrl: this.coordinatorUrl,
+          jwtToken,
+          // Safe: validated on line 186-188
+          model: this.model
         });
-        this.coordinatorClient.on(
-          "gpu-machine-assigned",
-          (assignmentData) => __async(this, null, function* () {
-            console.debug(
-              "[Reactor] GPU machine assigned by coordinator:",
-              assignmentData
-            );
-            try {
-              yield this.connectToGPUMachine(
-                assignmentData.livekitJwtToken,
-                assignmentData.livekitWsUrl
-              );
-            } catch (error) {
-              console.error("[Reactor] Failed to connect to GPU machine:", error);
-              this.createError(
-                "GPU_CONNECTION_FAILED",
-                `Failed to connect to GPU machine: ${error}`,
-                "gpu",
-                true
-              );
-              this.disconnect();
-            }
-          })
-        );
-        this.coordinatorClient.on(
-          "waiting-info",
-          (waitingData) => {
-            console.debug("[Reactor] Waiting info update received:", waitingData);
-            this.setWaitingInfo(__spreadValues(__spreadValues({}, this.waitingInfo), waitingData));
-          }
-        );
-        this.coordinatorClient.on(
-          "session-expiration",
-          (sessionExpirationData) => {
-            this.setSessionExpiration(sessionExpirationData.expire);
-          }
-        );
-        this.coordinatorClient.on(
-          "statusChanged",
-          (newStatus) => {
-            switch (newStatus) {
-              case "connected":
-                this.setStatus("waiting");
-                this.setWaitingInfo({
-                  position: void 0,
-                  estimatedWaitTime: void 0,
-                  averageWaitTime: void 0
-                });
-                break;
-              case "disconnected":
-                this.disconnect();
-                break;
-              case "error":
-                this.createError(
-                  "COORDINATOR_CONNECTION_ERROR",
-                  "Coordinator connection failed",
-                  "coordinator",
-                  true
-                );
-                this.disconnect();
-                break;
-            }
-          }
-        );
-        yield this.coordinatorClient.connect();
+        this.machineClient = new GPUMachineClient();
+        this.setupMachineClientHandlers();
+        const sdpOffer = yield this.machineClient.createOffer();
+        const sessionId = yield this.coordinatorClient.createSession(sdpOffer);
+        this.setSessionId(sessionId);
+        const sdpAnswer = yield this.coordinatorClient.connect(sessionId);
+        yield this.machineClient.connect(sdpAnswer);
       } catch (error) {
-        console.error("[Reactor] Authentication failed:", error);
+        console.error("[Reactor] Connection failed:", error);
         this.createError(
-          "AUTHENTICATION_FAILED",
-          `Authentication failed: ${error}`,
+          "CONNECTION_FAILED",
+          `Connection failed: ${error}`,
           "coordinator",
           true
         );
@@ -852,19 +1150,52 @@ var Reactor = class {
       }
     });
   }
+  /**
+   * Sets up event handlers for the machine client.
+   */
+  setupMachineClientHandlers() {
+    if (!this.machineClient) return;
+    this.machineClient.on("application", (message) => {
+      this.emit("newMessage", message);
+    });
+    this.machineClient.on("statusChanged", (status) => {
+      switch (status) {
+        case "connected":
+          this.setStatus("ready");
+          break;
+        case "disconnected":
+          this.disconnect(true);
+          break;
+        case "error":
+          this.createError(
+            "GPU_CONNECTION_ERROR",
+            "GPU machine connection failed",
+            "gpu",
+            true
+          );
+          this.disconnect();
+          break;
+      }
+    });
+    this.machineClient.on(
+      "trackReceived",
+      (track, stream) => {
+        this.emit("streamChanged", track, stream);
+      }
+    );
+  }
   /**
    * Disconnects from the coordinator and the gpu machine.
    * Ensures cleanup completes even if individual disconnections fail.
    */
-  disconnect() {
+  disconnect(recoverable = false) {
     return __async(this, null, function* () {
-      if (this.status === "disconnected") return;
-      if (this.coordinatorClient) {
-        try {
-          this.coordinatorClient.disconnect();
-        } catch (error) {
-          console.error("[Reactor] Error disconnecting from coordinator:", error);
-        }
+      if (this.status === "disconnected" && !this.sessionId) {
+        console.warn("[Reactor] Already disconnected");
+        return;
+      }
+      if (this.coordinatorClient && !recoverable) {
+        yield this.coordinatorClient.terminateSession();
         this.coordinatorClient = void 0;
       }
       if (this.machineClient) {
@@ -873,13 +1204,32 @@ var Reactor = class {
         } catch (error) {
           console.error("[Reactor] Error disconnecting from GPU machine:", error);
         }
-        this.machineClient = void 0;
+        if (!recoverable) {
+          this.machineClient = void 0;
+        }
       }
       this.setStatus("disconnected");
-      this.setSessionExpiration(void 0);
-      this.setWaitingInfo(void 0);
+      if (!recoverable) {
+        this.setSessionExpiration(void 0);
+        this.setSessionId(void 0);
+      }
     });
   }
+  setSessionId(newSessionId) {
+    console.debug(
+      "[Reactor] Setting session ID:",
+      newSessionId,
+      "from",
+      this.sessionId
+    );
+    if (this.sessionId !== newSessionId) {
+      this.sessionId = newSessionId;
+      this.emit("sessionIdChanged", newSessionId);
+    }
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
   setStatus(newStatus) {
     console.debug("[Reactor] Setting status:", newStatus, "from", this.status);
     if (this.status !== newStatus) {
@@ -887,17 +1237,8 @@ var Reactor = class {
       this.emit("statusChanged", newStatus);
     }
   }
-  setWaitingInfo(newWaitingInfo) {
-    console.debug(
-      "[Reactor] Setting waiting info:",
-      newWaitingInfo,
-      "from",
-      this.waitingInfo
-    );
-    if (this.waitingInfo !== newWaitingInfo) {
-      this.waitingInfo = newWaitingInfo;
-      this.emit("waitingInfoChanged", newWaitingInfo);
-    }
+  getStatus() {
+    return this.status;
   }
   /**
    * Set the session expiration time.
@@ -913,25 +1254,15 @@ var Reactor = class {
       this.emit("sessionExpirationChanged", newSessionExpiration);
     }
   }
-  getStatus() {
-    return this.status;
-  }
   /**
    * Get the current state including status, error, and waiting info
    */
   getState() {
     return {
       status: this.status,
-      waitingInfo: this.waitingInfo,
       lastError: this.lastError
     };
   }
-  /**
-   * Get waiting information when status is 'waiting'
-   */
-  getWaitingInfo() {
-    return this.waitingInfo;
-  }
   /**
    * Get the last error that occurred
    */
@@ -966,10 +1297,11 @@ var ReactorContext = (0, import_react2.createContext)(
 var defaultInitState = {
   status: "disconnected",
   videoTrack: null,
-  fps: void 0,
-  waitingInfo: void 0,
   lastError: void 0,
-  sessionExpiration: void 0
+  sessionExpiration: void 0,
+  insecureApiKey: void 0,
+  jwtToken: void 0,
+  sessionId: void 0
 };
 var initReactorStore = (props) => {
   return __spreadValues(__spreadValues({}, defaultInitState), props);
@@ -977,6 +1309,7 @@ var initReactorStore = (props) => {
 var createReactorStore = (initProps, publicState = defaultInitState) => {
   console.debug("[ReactorStore] Creating store", {
     coordinatorUrl: initProps.coordinatorUrl,
+    jwtToken: initProps.jwtToken,
     initialState: publicState
   });
   return (0, import_react.create)()((set, get) => {
@@ -989,37 +1322,37 @@ var createReactorStore = (initProps, publicState = defaultInitState) => {
       });
       set({ status: newStatus });
     });
-    reactor.on("waitingInfoChanged", (newWaitingInfo) => {
-      console.debug("[ReactorStore] Waiting info changed", {
-        oldWaitingInfo: get().waitingInfo,
-        newWaitingInfo
-      });
-      set({ waitingInfo: newWaitingInfo });
-    });
-    reactor.on("sessionExpirationChanged", (newSessionExpiration) => {
-      console.debug("[ReactorStore] Session expiration changed", {
-        oldSessionExpiration: get().sessionExpiration,
-        newSessionExpiration
-      });
-      set({ sessionExpiration: newSessionExpiration });
-    });
+    reactor.on(
+      "sessionExpirationChanged",
+      (newSessionExpiration) => {
+        console.debug("[ReactorStore] Session expiration changed", {
+          oldSessionExpiration: get().sessionExpiration,
+          newSessionExpiration
+        });
+        set({ sessionExpiration: newSessionExpiration });
+      }
+    );
     reactor.on("streamChanged", (videoTrack) => {
       console.debug("[ReactorStore] Stream changed", {
         hasVideoTrack: !!videoTrack,
         videoTrackKind: videoTrack == null ? void 0 : videoTrack.kind,
-        videoTrackSid: videoTrack == null ? void 0 : videoTrack.sid
+        videoTrackId: videoTrack == null ? void 0 : videoTrack.id
       });
       set({ videoTrack });
     });
-    reactor.on("fps", (fps) => {
-      console.debug("[ReactorStore] FPS updated", { fps });
-      set({ fps });
-    });
     reactor.on("error", (error) => {
       console.debug("[ReactorStore] Error occurred", error);
       set({ lastError: error });
     });
+    reactor.on("sessionIdChanged", (newSessionId) => {
+      console.debug("[ReactorStore] Session ID changed", {
+        oldSessionId: get().sessionId,
+        newSessionId
+      });
+      set({ sessionId: newSessionId });
+    });
     return __spreadProps(__spreadValues({}, publicState), {
+      jwtToken: initProps.jwtToken,
       internal: { reactor },
       // actions
       onMessage: (handler) => {
@@ -1030,32 +1363,35 @@ var createReactorStore = (initProps, publicState = defaultInitState) => {
           get().internal.reactor.off("newMessage", handler);
         };
       },
-      sendMessage: (mess) => __async(null, null, function* () {
-        console.debug("[ReactorStore] Sending message", { message: mess });
+      sendCommand: (command, data) => __async(null, null, function* () {
+        console.debug("[ReactorStore] Sending command", { command, data });
         try {
-          yield get().internal.reactor.sendMessage(mess);
-          console.debug("[ReactorStore] Message sent successfully");
+          yield get().internal.reactor.sendCommand(command, data);
+          console.debug("[ReactorStore] Command sent successfully");
         } catch (error) {
-          console.error("[ReactorStore] Failed to send message:", error);
+          console.error("[ReactorStore] Failed to send command:", error);
           throw error;
         }
       }),
-      connect: () => __async(null, null, function* () {
-        console.debug("[ReactorStore] Connect called");
+      connect: (jwtToken) => __async(null, null, function* () {
+        if (jwtToken === void 0) {
+          jwtToken = get().jwtToken;
+        }
+        console.debug("[ReactorStore] Connect called.");
         try {
-          yield get().internal.reactor.connect();
+          yield get().internal.reactor.connect(jwtToken);
           console.debug("[ReactorStore] Connect completed successfully");
         } catch (error) {
           console.error("[ReactorStore] Connect failed:", error);
           throw error;
         }
       }),
-      disconnect: () => __async(null, null, function* () {
+      disconnect: (recoverable = false) => __async(null, null, function* () {
         console.debug("[ReactorStore] Disconnect called", {
           currentStatus: get().status
         });
         try {
-          yield get().internal.reactor.disconnect();
+          yield get().internal.reactor.disconnect(recoverable);
           console.debug("[ReactorStore] Disconnect completed successfully");
         } catch (error) {
           console.error("[ReactorStore] Disconnect failed:", error);
@@ -1065,7 +1401,7 @@ var createReactorStore = (initProps, publicState = defaultInitState) => {
       publishVideoStream: (stream) => __async(null, null, function* () {
         console.debug("[ReactorStore] Publishing video stream");
         try {
-          yield get().internal.reactor.publishVideoStream(stream);
+          yield get().internal.reactor.publishTrack(stream.getVideoTracks()[0]);
           console.debug("[ReactorStore] Video stream published successfully");
         } catch (error) {
           console.error(
@@ -1078,7 +1414,7 @@ var createReactorStore = (initProps, publicState = defaultInitState) => {
       unpublishVideoStream: () => __async(null, null, function* () {
         console.debug("[ReactorStore] Unpublishing video stream");
         try {
-          yield get().internal.reactor.unpublishVideoStream();
+          yield get().internal.reactor.unpublishTrack();
           console.debug("[ReactorStore] Video stream unpublished successfully");
         } catch (error) {
           console.error(
@@ -1087,6 +1423,16 @@ var createReactorStore = (initProps, publicState = defaultInitState) => {
           );
           throw error;
         }
+      }),
+      reconnect: () => __async(null, null, function* () {
+        console.debug("[ReactorStore] Reconnecting");
+        try {
+          yield get().internal.reactor.reconnect();
+          console.debug("[ReactorStore] Reconnect completed successfully");
+        } catch (error) {
+          console.error("[ReactorStore] Failed to reconnect:", error);
+          throw error;
+        }
       })
     });
   });
@@ -1098,37 +1444,48 @@ var import_jsx_runtime = require("react/jsx-runtime");
 function ReactorProvider(_a) {
   var _b = _a, {
     children,
-    autoConnect = true
+    autoConnect = true,
+    jwtToken
   } = _b, props = __objRest(_b, [
     "children",
-    "autoConnect"
+    "autoConnect",
+    "jwtToken"
   ]);
   const storeRef = (0, import_react3.useRef)(void 0);
   const firstRender = (0, import_react3.useRef)(true);
   const [_storeVersion, setStoreVersion] = (0, import_react3.useState)(0);
   if (storeRef.current === void 0) {
     console.debug("[ReactorProvider] Creating new reactor store");
-    storeRef.current = createReactorStore(initReactorStore(props));
+    storeRef.current = createReactorStore(
+      initReactorStore(__spreadProps(__spreadValues({}, props), {
+        jwtToken
+      }))
+    );
     console.debug("[ReactorProvider] Reactor store created successfully");
   }
-  const {
-    coordinatorUrl,
-    modelName,
-    jwtToken,
-    insecureApiKey,
-    directConnection,
-    queueing,
-    local
-  } = props;
+  const { coordinatorUrl, modelName, local } = props;
+  (0, import_react3.useEffect)(() => {
+    const handleBeforeUnload = () => {
+      var _a2;
+      console.debug(
+        "[ReactorProvider] Page unloading, performing non-recoverable disconnect"
+      );
+      (_a2 = storeRef.current) == null ? void 0 : _a2.getState().internal.reactor.disconnect(false);
+    };
+    window.addEventListener("beforeunload", handleBeforeUnload);
+    return () => {
+      window.removeEventListener("beforeunload", handleBeforeUnload);
+    };
+  }, []);
   (0, import_react3.useEffect)(() => {
     if (firstRender.current) {
       firstRender.current = false;
       const current2 = storeRef.current;
-      if (autoConnect && current2.getState().status === "disconnected") {
+      if (autoConnect && current2.getState().status === "disconnected" && jwtToken) {
         console.debug(
           "[ReactorProvider] Starting autoconnect in first render..."
         );
-        current2.getState().connect().then(() => {
+        current2.getState().connect(jwtToken).then(() => {
           console.debug(
             "[ReactorProvider] Autoconnect successful in first render"
           );
@@ -1160,11 +1517,8 @@ function ReactorProvider(_a) {
       initReactorStore({
         coordinatorUrl,
         modelName,
-        jwtToken,
-        insecureApiKey,
-        directConnection,
-        queueing,
-        local
+        local,
+        jwtToken
       })
     );
     const current = storeRef.current;
@@ -1172,9 +1526,9 @@ function ReactorProvider(_a) {
     console.debug(
       "[ReactorProvider] Reactor store updated successfully, and increased version"
     );
-    if (autoConnect && current.getState().status === "disconnected") {
+    if (autoConnect && current.getState().status === "disconnected" && jwtToken) {
       console.debug("[ReactorProvider] Starting autoconnect...");
-      current.getState().connect().then(() => {
+      current.getState().connect(jwtToken).then(() => {
         console.debug("[ReactorProvider] Autoconnect successful");
       }).catch((error) => {
         console.error("[ReactorProvider] Failed to autoconnect:", error);
@@ -1190,16 +1544,7 @@ function ReactorProvider(_a) {
         console.error("[ReactorProvider] Failed to disconnect:", error);
       });
     };
-  }, [
-    coordinatorUrl,
-    modelName,
-    jwtToken,
-    insecureApiKey,
-    directConnection,
-    queueing,
-    autoConnect,
-    local
-  ]);
+  }, [coordinatorUrl, modelName, autoConnect, local, jwtToken]);
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ReactorContext.Provider, { value: storeRef.current, children });
 }
 function useReactorStore(selector) {
@@ -1261,7 +1606,11 @@ function ReactorView({
     if (videoRef.current && videoTrack) {
       console.debug("[ReactorView] Attaching video track to element");
       try {
-        videoTrack.attach(videoRef.current);
+        const stream = new MediaStream([videoTrack]);
+        videoRef.current.srcObject = stream;
+        videoRef.current.play().catch((e) => {
+          console.warn("[ReactorView] Auto-play failed:", e);
+        });
         console.debug("[ReactorView] Video track attached successfully");
       } catch (error) {
         console.error("[ReactorView] Failed to attach video track:", error);
@@ -1269,12 +1618,8 @@ function ReactorView({
       return () => {
         console.debug("[ReactorView] Detaching video track from element");
         if (videoRef.current) {
-          try {
-            videoTrack.detach(videoRef.current);
-            console.debug("[ReactorView] Video track detached successfully");
-          } catch (error) {
-            console.error("[ReactorView] Failed to detach video track:", error);
-          }
+          videoRef.current.srcObject = null;
+          console.debug("[ReactorView] Video track detached successfully");
         }
       };
     } else {
@@ -1339,8 +1684,8 @@ function ReactorController({
   className,
   style
 }) {
-  const { sendMessage, status } = useReactor((state) => ({
-    sendMessage: state.sendMessage,
+  const { sendCommand, status } = useReactor((state) => ({
+    sendCommand: state.sendCommand,
     status: state.status
   }));
   const [commands, setCommands] = (0, import_react6.useState)({});
@@ -1355,12 +1700,9 @@ function ReactorController({
   }, [status]);
   const requestCapabilities = (0, import_react6.useCallback)(() => {
     if (status === "ready") {
-      sendMessage({
-        type: "requestCapabilities",
-        data: {}
-      });
+      sendCommand("requestCapabilities", {});
     }
-  }, [status, sendMessage]);
+  }, [status, sendCommand]);
   import_react6.default.useEffect(() => {
     if (status === "ready") {
       requestCapabilities();
@@ -1451,12 +1793,9 @@ function ReactorController({
         }
       });
       console.log(`Executing command: ${commandName}`, data);
-      yield sendMessage({
-        type: commandName,
-        data
-      });
+      yield sendCommand(commandName, data);
     }),
-    [formValues, sendMessage, commands]
+    [formValues, sendCommand, commands]
   );
   const renderInput = (commandName, paramName, paramSchema) => {
     var _a, _b;
@@ -1982,6 +2321,7 @@ function WebcamStream({
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  PROD_COORDINATOR_URL,
   Reactor,
   ReactorController,
   ReactorProvider,