@reactor-team/js-sdk 1.0.6 → 1.0.7

package/src/core/GPUMachineClient.ts

@@ -1,172 +0,0 @@
-/**
- * The GPUMachineClient is responsible for handling the direct connection to the machine instance
- * after the coordinator has assigned a machine.
- */
-
-import {
-  type GPUMachineSendMessage,
-  GPUMachineReceiveMessageSchema,
-} from "./types";
-import { Room, RoomEvent, Track, RemoteVideoTrack } from "livekit-client";
-
-type EventHandler = (...args: any[]) => void;
-export type GPUMachineEvent =
-  | GPUMachineReceiveMessageSchema["type"]
-  | "statusChanged"
-  | "streamChanged";
-
-export class GPUMachineClient {
-  private eventListeners: Map<GPUMachineEvent, Set<EventHandler>> = new Map();
-  private roomInstance: Room | undefined;
-  private machineFPS: number | undefined;
-  private token: string;
-  private videoStream: MediaStream | undefined;
-  private liveKitUrl: string;
-
-  constructor(token: string, liveKitUrl: string) {
-    this.token = token;
-    this.liveKitUrl = liveKitUrl;
-  }
-
-  // Event Emitter API
-  on(event: GPUMachineEvent, handler: EventHandler) {
-    if (!this.eventListeners.has(event)) {
-      this.eventListeners.set(event, new Set());
-    }
-    this.eventListeners.get(event)!.add(handler);
-  }
-
-  off(event: GPUMachineEvent, handler: EventHandler) {
-    this.eventListeners.get(event)?.delete(handler);
-  }
-
-  emit(event: GPUMachineEvent, ...args: any[]) {
-    this.eventListeners.get(event)?.forEach((handler) => handler(...args));
-  }
-
-  sendMessage(message: GPUMachineSendMessage) {
-    try {
-      if (this.roomInstance) {
-        const messageStr = JSON.stringify(message);
-        // Send message via LiveKit text channel
-        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");
-    }
-  }
-
-  async connect(): Promise<void> {
-    this.roomInstance = new Room({
-      adaptiveStream: true,
-      dynacast: true,
-    });
-
-    this.roomInstance.on(RoomEvent.Connected, () => {
-      console.debug("[GPUMachineClient] Connected to room");
-      this.emit("statusChanged", "connected");
-    });
-
-    this.roomInstance.on(RoomEvent.Disconnected, () => {
-      console.debug("[GPUMachineClient] Disconnected from room");
-      this.emit("statusChanged", "disconnected");
-    });
-
-    // Handle video track subscriptions from GPU machine
-    this.roomInstance.on(
-      RoomEvent.TrackSubscribed,
-      (track, _publication, participant) => {
-        console.debug(
-          "[GPUMachineClient] Track subscribed:",
-          track.kind,
-          participant.identity
-        );
-
-        if (track.kind === Track.Kind.Video) {
-          const videoTrack = track as RemoteVideoTrack;
-          this.emit("streamChanged", videoTrack);
-        }
-      }
-    );
-
-    this.roomInstance.on(
-      RoomEvent.TrackUnsubscribed,
-      (track, _publication, participant) => {
-        console.debug(
-          "[GPUMachineClient] Track unsubscribed:",
-          track.kind,
-          participant.identity
-        );
-
-        if (track.kind === Track.Kind.Video) {
-          this.emit("streamChanged", null);
-        }
-      }
-    );
-
-    this.roomInstance.registerTextStreamHandler(
-      "application",
-      async (reader, participant) => {
-        const text = await 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");
-        }
-      }
-    );
-
-    await this.roomInstance.connect(this.liveKitUrl, this.token);
-
-    console.log("[GPUMachineClient] Room connected");
-  }
-
-  /**
-   * Closes the LiveKit connection if it exists.
-   * This will trigger the onclose event handler.
-   */
-  async disconnect() {
-    if (this.roomInstance) {
-      console.debug("[GPUMachineClient] Closing LiveKit connection");
-      await this.roomInstance.disconnect();
-      this.roomInstance = undefined;
-    }
-    this.machineFPS = undefined;
-  }
-
-  /**
-   * Returns the current fps rate of the machine.
-   * @returns The current fps rate of the machine.
-   */
-  getFPS(): number | undefined {
-    return this.machineFPS;
-  }
-
-  /**
-   * Returns the current video stream from the GPU machine.
-   * @returns The current video stream or undefined if not available.
-   */
-  getVideoStream(): MediaStream | undefined {
-    return this.videoStream;
-  }
-}

package/src/core/Reactor.ts

@@ -1,406 +0,0 @@
-import type {
-  ApplicationMessage,
-  InternalConnectionStatus,
-  GPUMachineAssignmentData,
-} from "./types";
-import type {
-  ReactorEvent,
-  ReactorStatus,
-  ReactorState,
-  ReactorError,
-  ReactorWaitingInfo,
-} from "../types";
-import { CoordinatorClient } from "./CoordinatorClient";
-import { GPUMachineClient } from "./GPUMachineClient";
-import { z } from "zod";
-
-const OptionsSchema = z
-  .object({
-    directConnection: z
-      .object({
-        livekitJwtToken: z.string(),
-        livekitWsUrl: z.string(),
-      })
-      .optional(),
-    insecureApiKey: z.string().optional(),
-    jwtToken: z.string().optional(),
-    coordinatorUrl: z.string().default("wss://api.reactor.inc/ws"),
-    modelName: z.string(),
-  })
-  .refine(
-    (data) => data.directConnection || data.insecureApiKey || data.jwtToken,
-    {
-      message:
-        "At least one of directConnection, insecureApiKey, or jwtToken must be provided.",
-    }
-  );
-export type Options = z.input<typeof OptionsSchema>;
-
-type EventHandler = (...args: any[]) => void;
-
-export class Reactor {
-  private coordinatorClient: CoordinatorClient | undefined; //client for the coordinator
-  private machineClient: GPUMachineClient | undefined; //client for the machine instance
-  private status: ReactorStatus = "disconnected";
-  private coordinatorUrl: string;
-  private lastError?: ReactorError;
-  private waitingInfo?: ReactorWaitingInfo;
-  private jwtToken?: string;
-  private insecureApiKey?: string;
-  private directConnection?: {
-    livekitJwtToken: string;
-    livekitWsUrl: string;
-  };
-  private modelName: string;
-  private modelVersion: string;
-
-  constructor(options: 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;
-    // TODO: Use the model version from the options once we have a way to handle multiple versions
-    this.modelVersion = "1.0.0";
-  }
-
-  // Generic event map
-  private eventListeners: Map<ReactorEvent, Set<EventHandler>> = new Map();
-
-  // Event Emitter API
-  on(event: ReactorEvent, handler: EventHandler) {
-    if (!this.eventListeners.has(event)) {
-      this.eventListeners.set(event, new Set());
-    }
-    this.eventListeners.get(event)!.add(handler);
-  }
-
-  off(event: ReactorEvent, handler: EventHandler) {
-    this.eventListeners.get(event)?.delete(handler);
-  }
-
-  emit(event: ReactorEvent, ...args: any[]) {
-    this.eventListeners.get(event)?.forEach((handler) => handler(...args));
-  }
-
-  /**
-   * Public method to send a message to the machine.
-   * Automatically wraps the message in an application message.
-   * @param message The message to send to the machine.
-   * @throws Error if not in ready state
-   */
-  sendMessage(message: any) {
-    // Synchronous validation - throw immediately
-    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);
-    }
-
-    try {
-      // Automatically wrap the user-message in an application message.
-      const applicationMessage: ApplicationMessage = {
-        type: "application",
-        data: message,
-      };
-      this.machineClient?.sendMessage(applicationMessage);
-    } catch (error) {
-      // Async operational error - emit event only
-      console.error("[Reactor] Failed to send message:", error);
-      this.createError(
-        "MESSAGE_SEND_FAILED",
-        `Failed to send message: ${error}`,
-        "gpu",
-        true
-      );
-      // Don't re-throw - let the error event handle it
-    }
-  }
-
-  /**
-   * 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
-   */
-  private async connectToGPUMachine(
-    livekitJwtToken: string,
-    livekitWsUrl: string
-  ) {
-    console.debug("[Reactor] Connecting to machine room...");
-
-    try {
-      this.machineClient = new GPUMachineClient(livekitJwtToken, livekitWsUrl);
-
-      this.machineClient.on("application", (message: any) => {
-        // escalate the message event through the instance, so that the user can listen to it.
-        this.emit("newMessage", message);
-      });
-
-      this.machineClient.on(
-        "statusChanged",
-        (status: InternalConnectionStatus) => {
-          switch (status) {
-            case "connected":
-              this.setStatus("ready");
-              break;
-            case "disconnected":
-              // gpu machine has disconnected. Close any other connection to any other entity
-              // such as the coordinator or the LiveKit connection.
-              this.disconnect();
-              break;
-            case "error":
-              // gpu machine has errored. Close any other connection to any other entity
-              // such as the coordinator or the LiveKit connection.
-              this.createError(
-                "GPU_CONNECTION_ERROR",
-                "GPU machine connection failed",
-                "gpu",
-                true
-              );
-              this.disconnect();
-              break;
-          }
-        }
-      );
-
-      this.machineClient.on("fps", (fps: number) => {
-        this.emit("fps", fps);
-      });
-
-      this.machineClient.on("streamChanged", (videoTrack) => {
-        this.emit("streamChanged", videoTrack);
-      });
-
-      console.debug("[Reactor] About to connect to machine");
-      await this.machineClient.connect();
-    } catch (error) {
-      // For private methods, we can still throw since the caller will handle it appropriately
-      throw error;
-    }
-  }
-
-  /**
-   * 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.
-   */
-  async connect(): Promise<void> {
-    console.debug("[Reactor] Connecting, status:", this.status);
-
-    // Synchronous validation - throw immediately
-    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,
-      });
-
-      this.coordinatorClient.on(
-        "gpu-machine-assigned",
-        async (assignmentData: GPUMachineAssignmentData) => {
-          console.debug(
-            "[Reactor] GPU machine assigned by coordinator:",
-            assignmentData
-          );
-          try {
-            await this.connectToGPUMachine(
-              assignmentData.livekitJwtToken,
-              assignmentData.livekitWsUrl
-            );
-          } catch (error) {
-            console.error("[Reactor] Failed to connect to GPU machine:", error);
-            // Emit error event for async GPU connection failure
-            this.createError(
-              "GPU_CONNECTION_FAILED",
-              `Failed to connect to GPU machine: ${error}`,
-              "gpu",
-              true
-            );
-            this.disconnect();
-          }
-        }
-      );
-
-      this.coordinatorClient.on(
-        "waiting-info",
-        (waitingData: ReactorWaitingInfo) => {
-          console.debug("[Reactor] Waiting info update received:", waitingData);
-          // Update waiting info
-          this.setWaitingInfo({
-            ...this.waitingInfo,
-            ...waitingData,
-          });
-        }
-      );
-
-      this.coordinatorClient.on(
-        "statusChanged",
-        (newStatus: InternalConnectionStatus) => {
-          switch (newStatus) {
-            case "connected":
-              this.setStatus("waiting");
-              // Initialize waiting info when entering waiting state
-              this.setWaitingInfo({
-                position: undefined,
-                estimatedWaitTime: undefined,
-                averageWaitTime: undefined,
-              });
-              break;
-            case "disconnected":
-              this.disconnect();
-              break;
-            case "error":
-              this.createError(
-                "COORDINATOR_CONNECTION_ERROR",
-                "Coordinator connection failed",
-                "coordinator",
-                true
-              );
-              this.disconnect();
-              break;
-          }
-        }
-      );
-
-      await this.coordinatorClient.connect();
-    } catch (error) {
-      console.error("[Reactor] Authentication failed:", error);
-      this.createError(
-        "AUTHENTICATION_FAILED",
-        `Authentication failed: ${error}`,
-        "coordinator",
-        true
-      );
-      this.setStatus("disconnected");
-      // Keep throwing for authentication failures as these are immediate/sync failures
-      throw error;
-    }
-  }
-
-  /**
-   * Disconnects from the coordinator and the gpu machine.
-   * Ensures cleanup completes even if individual disconnections fail.
-   */
-  async disconnect() {
-    if (this.status === "disconnected") return;
-
-    // Disconnect coordinator client with error handling
-    if (this.coordinatorClient) {
-      try {
-        this.coordinatorClient.disconnect();
-      } catch (error) {
-        console.error("[Reactor] Error disconnecting from coordinator:", error);
-        // Continue with cleanup even if coordinator disconnect fails
-      }
-      this.coordinatorClient = undefined;
-    }
-
-    // Disconnect machine client with error handling
-    if (this.machineClient) {
-      try {
-        await this.machineClient.disconnect();
-      } catch (error) {
-        console.error("[Reactor] Error disconnecting from GPU machine:", error);
-        // Continue with cleanup even if machine disconnect fails
-      }
-      this.machineClient = undefined;
-    }
-
-    this.setStatus("disconnected");
-
-    // Clear waiting info when disconnecting
-    this.waitingInfo = undefined;
-  }
-
-  private setStatus(newStatus: ReactorStatus) {
-    console.debug("[Reactor] Setting status:", newStatus, "from", this.status);
-    if (this.status !== newStatus) {
-      this.status = newStatus;
-      this.emit("statusChanged", newStatus);
-    }
-  }
-
-  private setWaitingInfo(newWaitingInfo: ReactorWaitingInfo) {
-    console.debug(
-      "[Reactor] Setting waiting info:",
-      newWaitingInfo,
-      "from",
-      this.waitingInfo
-    );
-    if (this.waitingInfo !== newWaitingInfo) {
-      this.waitingInfo = newWaitingInfo;
-      this.emit("waitingInfoChanged", newWaitingInfo);
-    }
-  }
-
-  getStatus(): ReactorStatus {
-    return this.status;
-  }
-
-  /**
-   * Get the current state including status, error, and waiting info
-   */
-  getState(): ReactorState {
-    return {
-      status: this.status,
-      waitingInfo: this.waitingInfo,
-      lastError: this.lastError,
-    };
-  }
-
-  /**
-   * Get waiting information when status is 'waiting'
-   */
-  getWaitingInfo(): ReactorWaitingInfo | undefined {
-    return this.waitingInfo;
-  }
-
-  /**
-   * Get the last error that occurred
-   */
-  getLastError(): ReactorError | undefined {
-    return this.lastError;
-  }
-
-  /**
-   * Create and store an error
-   */
-  private createError(
-    code: string,
-    message: string,
-    component: "coordinator" | "gpu" | "livekit",
-    recoverable: boolean,
-    retryAfter?: number
-  ) {
-    this.lastError = {
-      code,
-      message,
-      timestamp: Date.now(),
-      recoverable,
-      component,
-      retryAfter,
-    };
-
-    // Emit error event
-    this.emit("error", this.lastError);
-  }
-}