@reactor-team/js-sdk 1.0.9 → 1.0.11

package/dist/index.d.mts

@@ -33,6 +33,7 @@ declare const OptionsSchema: z.ZodObject<{
     jwtToken: z.ZodOptional<z.ZodString>;
     coordinatorUrl: z.ZodDefault<z.ZodString>;
     modelName: z.ZodString;
+    queueing: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
 type Options = z.input<typeof OptionsSchema>;
 type EventHandler = (...args: any[]) => void;
@@ -48,6 +49,7 @@ declare class Reactor {
     private directConnection?;
     private modelName;
     private modelVersion;
+    private queueing;
     constructor(options: Options);
     private eventListeners;
     on(event: ReactorEvent, handler: EventHandler): void;
@@ -60,6 +62,16 @@ declare class Reactor {
      * @throws Error if not in ready state
      */
     sendMessage(message: any): Promise<void>;
+    /**
+     * Public method to publish a video stream to the machine.
+     * @param videoStream The video stream to send to the machine.
+     */
+    publishVideoStream(videoStream: MediaStream): Promise<void>;
+    /**
+     * Public method to unpublish video stream to the machine.
+     * This unpublishes the video track that was previously sent.
+     */
+    unpublishVideoStream(): Promise<void>;
     /**
      * 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.

package/dist/index.d.ts

@@ -33,6 +33,7 @@ declare const OptionsSchema: z.ZodObject<{
     jwtToken: z.ZodOptional<z.ZodString>;
     coordinatorUrl: z.ZodDefault<z.ZodString>;
     modelName: z.ZodString;
+    queueing: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
 type Options = z.input<typeof OptionsSchema>;
 type EventHandler = (...args: any[]) => void;
@@ -48,6 +49,7 @@ declare class Reactor {
     private directConnection?;
     private modelName;
     private modelVersion;
+    private queueing;
     constructor(options: Options);
     private eventListeners;
     on(event: ReactorEvent, handler: EventHandler): void;
@@ -60,6 +62,16 @@ declare class Reactor {
      * @throws Error if not in ready state
      */
     sendMessage(message: any): Promise<void>;
+    /**
+     * Public method to publish a video stream to the machine.
+     * @param videoStream The video stream to send to the machine.
+     */
+    publishVideoStream(videoStream: MediaStream): Promise<void>;
+    /**
+     * Public method to unpublish video stream to the machine.
+     * This unpublishes the video track that was previously sent.
+     */
+    unpublishVideoStream(): Promise<void>;
     /**
      * 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.

package/dist/index.js

@@ -142,7 +142,8 @@ var OptionsSchema = import_zod2.z.object({
   jwtToken: import_zod2.z.string().optional(),
   insecureApiKey: import_zod2.z.string().optional(),
   modelName: import_zod2.z.string(),
-  modelVersion: import_zod2.z.string().default("latest")
+  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."
 });
@@ -155,6 +156,7 @@ var CoordinatorClient = class {
     this.insecureApiKey = validatedOptions.insecureApiKey;
     this.modelName = validatedOptions.modelName;
     this.modelVersion = validatedOptions.modelVersion;
+    this.queueing = validatedOptions.queueing;
   }
   // Event Emitter API
   on(event, handler) {
@@ -189,6 +191,9 @@ var CoordinatorClient = class {
       } else if (this.insecureApiKey) {
         url.searchParams.set("api_key", this.insecureApiKey);
       }
+      if (this.queueing) {
+        url.searchParams.set("queueing", "true");
+      }
       console.debug("[CoordinatorClient] Connecting to", url.toString());
       this.websocket = new WebSocket(url.toString());
       this.websocket.onopen = () => {
@@ -382,6 +387,12 @@ var GPUMachineClient = class {
    */
   disconnect() {
     return __async(this, null, function* () {
+      if (this.publishedVideoTrack) {
+        yield this.unpublishVideoTrack();
+      }
+      if (this.publishedAudioTrack) {
+        yield this.unpublishAudioTrack();
+      }
       if (this.roomInstance) {
         console.debug("[GPUMachineClient] Closing LiveKit connection");
         yield this.roomInstance.disconnect();
@@ -404,6 +415,126 @@ var GPUMachineClient = class {
   getVideoStream() {
     return this.videoStream;
   }
+  /**
+   * 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
+   */
+  publishVideoTrack(mediaStream) {
+    return __async(this, null, function* () {
+      if (!this.roomInstance) {
+        throw new Error(
+          "[GPUMachineClient] Cannot publish track - not connected to room"
+        );
+      }
+      const videoTracks = mediaStream.getVideoTracks();
+      if (videoTracks.length === 0) {
+        throw new Error("[GPUMachineClient] No video track found in MediaStream");
+      }
+      if (this.publishedVideoTrack) {
+        yield this.unpublishVideoTrack();
+      }
+      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");
+      } catch (error) {
+        console.error("[GPUMachineClient] Failed to publish video track:", error);
+        throw error;
+      }
+    });
+  }
+  /**
+   * Unpublishes the currently published video track.
+   */
+  unpublishVideoTrack() {
+    return __async(this, null, function* () {
+      if (!this.roomInstance || !this.publishedVideoTrack) {
+        return;
+      }
+      try {
+        yield this.roomInstance.localParticipant.unpublishTrack(
+          this.publishedVideoTrack
+        );
+        this.publishedVideoTrack.stop();
+        this.publishedVideoTrack = void 0;
+        console.debug("[GPUMachineClient] Video track unpublished successfully");
+      } catch (error) {
+        console.error(
+          "[GPUMachineClient] Failed to unpublish video track:",
+          error
+        );
+        throw error;
+      }
+    });
+  }
+  /**
+   * 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
+   */
+  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;
+      }
+    });
+  }
+  /**
+   * Unpublishes the currently published audio track.
+   * @private
+   */
+  unpublishAudioTrack() {
+    return __async(this, null, function* () {
+      if (!this.roomInstance || !this.publishedAudioTrack) {
+        return;
+      }
+      try {
+        yield this.roomInstance.localParticipant.unpublishTrack(
+          this.publishedAudioTrack
+        );
+        this.publishedAudioTrack.stop();
+        this.publishedAudioTrack = void 0;
+        console.debug("[GPUMachineClient] Audio track unpublished successfully");
+      } catch (error) {
+        console.error(
+          "[GPUMachineClient] Failed to unpublish audio track:",
+          error
+        );
+        throw error;
+      }
+    });
+  }
 };
 
 // src/core/Reactor.ts
@@ -416,7 +547,8 @@ var OptionsSchema2 = import_zod3.z.object({
   insecureApiKey: import_zod3.z.string().optional(),
   jwtToken: import_zod3.z.string().optional(),
   coordinatorUrl: import_zod3.z.string().default("wss://api.reactor.inc/ws"),
-  modelName: import_zod3.z.string()
+  modelName: import_zod3.z.string(),
+  queueing: import_zod3.z.boolean().default(false)
 }).refine(
   (data) => data.directConnection || data.insecureApiKey || data.jwtToken,
   {
@@ -435,6 +567,7 @@ var Reactor = class {
     this.insecureApiKey = validatedOptions.insecureApiKey;
     this.directConnection = validatedOptions.directConnection;
     this.modelName = validatedOptions.modelName;
+    this.queueing = validatedOptions.queueing;
     this.modelVersion = "1.0.0";
   }
   // Event Emitter API
@@ -483,6 +616,51 @@ var Reactor = class {
       }
     });
   }
+  /**
+   * Public method to publish a video stream to the machine.
+   * @param videoStream The video stream to send to the machine.
+   */
+  publishVideoStream(videoStream) {
+    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);
+      }
+      try {
+        yield (_a = this.machineClient) == null ? void 0 : _a.publishVideoTrack(videoStream);
+      } catch (error) {
+        console.error("[Reactor] Failed to publish video:", error);
+        this.createError(
+          "VIDEO_PUBLISH_FAILED",
+          `Failed to publish video: ${error}`,
+          "gpu",
+          true
+        );
+      }
+    });
+  }
+  /**
+   * Public method to unpublish video stream to the machine.
+   * This unpublishes the video track that was previously sent.
+   */
+  unpublishVideoStream() {
+    return __async(this, null, function* () {
+      var _a;
+      try {
+        yield (_a = this.machineClient) == null ? void 0 : _a.unpublishVideoTrack();
+      } catch (error) {
+        console.error("[Reactor] Failed to unpublish video:", error);
+        this.createError(
+          "VIDEO_UNPUBLISH_FAILED",
+          `Failed to unpublish video: ${error}`,
+          "gpu",
+          true
+        );
+      }
+    });
+  }
   /**
    * 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.
@@ -557,7 +735,8 @@ var Reactor = class {
           jwtToken: this.jwtToken,
           insecureApiKey: this.insecureApiKey,
           modelName: this.modelName,
-          modelVersion: this.modelVersion
+          modelVersion: this.modelVersion,
+          queueing: this.queueing
         });
         this.coordinatorClient.on(
           "gpu-machine-assigned",
@@ -835,34 +1014,98 @@ function ReactorProvider(_a) {
   ]);
   const storeRef = (0, import_react3.useRef)(void 0);
   const firstRender = (0, import_react3.useRef)(true);
-  function attemptAutoConnect() {
-    var _a2, _b2;
-    const status = (_a2 = storeRef.current) == null ? void 0 : _a2.getState().status;
-    if (autoConnect && status === "disconnected") {
-      console.debug("[ReactorProvider] Starting autoconnect...");
-      (_b2 = storeRef.current) == null ? void 0 : _b2.getState().connect().then(() => {
-        console.debug("[ReactorProvider] Autoconnect successful");
-      }).catch((error) => {
-        console.error("[ReactorProvider] Failed to autoconnect:", error);
-      });
-    }
-  }
+  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));
     console.debug("[ReactorProvider] Reactor store created successfully");
-    attemptAutoConnect();
   }
+  const {
+    coordinatorUrl,
+    modelName,
+    jwtToken,
+    insecureApiKey,
+    directConnection,
+    queueing
+  } = props;
   (0, import_react3.useEffect)(() => {
     if (firstRender.current) {
       firstRender.current = false;
-      return;
+      const current2 = storeRef.current;
+      if (autoConnect && current2.getState().status === "disconnected") {
+        console.debug(
+          "[ReactorProvider] Starting autoconnect in first render..."
+        );
+        current2.getState().connect().then(() => {
+          console.debug(
+            "[ReactorProvider] Autoconnect successful in first render"
+          );
+        }).catch((error) => {
+          console.error(
+            "[ReactorProvider] Failed to autoconnect in first render:",
+            error
+          );
+        });
+      }
+      return () => {
+        console.debug(
+          "[ReactorProvider] Disconnecting in cleanup for first render"
+        );
+        current2.getState().disconnect().then(() => {
+          console.debug(
+            "[ReactorProvider] Disconnect completed successfully in cleanup for first render"
+          );
+        }).catch((error) => {
+          console.error(
+            "[ReactorProvider] Failed to disconnect in cleanup for first render:",
+            error
+          );
+        });
+      };
     }
     console.debug("[ReactorProvider] Updating reactor store");
-    storeRef.current = createReactorStore(initReactorStore(props));
-    console.debug("[ReactorProvider] Reactor store updated successfully");
-    attemptAutoConnect();
-  }, [props, autoConnect]);
+    storeRef.current = createReactorStore(
+      initReactorStore({
+        coordinatorUrl,
+        modelName,
+        jwtToken,
+        insecureApiKey,
+        directConnection,
+        queueing
+      })
+    );
+    const current = storeRef.current;
+    setStoreVersion((v) => v + 1);
+    console.debug(
+      "[ReactorProvider] Reactor store updated successfully, and increased version"
+    );
+    if (autoConnect && current.getState().status === "disconnected") {
+      console.debug("[ReactorProvider] Starting autoconnect...");
+      current.getState().connect().then(() => {
+        console.debug("[ReactorProvider] Autoconnect successful");
+      }).catch((error) => {
+        console.error("[ReactorProvider] Failed to autoconnect:", error);
+      });
+    }
+    return () => {
+      console.debug("[ReactorProvider] Disconnecting in cleanup");
+      current.getState().disconnect().then(() => {
+        console.debug(
+          "[ReactorProvider] Disconnect completed successfully in cleanup"
+        );
+      }).catch((error) => {
+        console.error("[ReactorProvider] Failed to disconnect:", error);
+      });
+    };
+  }, [
+    coordinatorUrl,
+    modelName,
+    jwtToken,
+    insecureApiKey,
+    directConnection,
+    queueing,
+    autoConnect
+  ]);
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ReactorContext.Provider, { value: storeRef.current, children });
 }
 function useReactorStore(selector) {