Quickstart

REACTOR_API_KEY=rk_your_api_key_here

import { NextResponse } from "next/server";

export async function POST() {
  const r = await fetch("https://api.reactor.inc/tokens", {
    method: "POST",
    headers: {
      "Reactor-API-Key": process.env.REACTOR_API_KEY!,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      authorization_details: [
        { type: "session", resources: { models: { match: ["reactor/helios"] } } },
      ],
    }),
  });
  const { jwt } = await r.json();

  return NextResponse.json({ jwt });
}

"use client";

import { use, useEffect } from "react";
import { ReactorProvider, ReactorView, useReactor } from "@reactor-team/js-sdk";

async function getToken() {
  const r = await fetch("/api/token", { method: "POST" });
  const { jwt } = await r.json();
  return jwt;
}

const tokenPromise = getToken();

// Once the session is ready, send a prompt and start generating.
function AutoStart() {
  const { status, sendCommand } = useReactor((s) => s);

  useEffect(() => {
    if (status !== "ready") return;
    sendCommand("set_prompt", { prompt: "A serene mountain landscape at sunrise" });
    sendCommand("start", {});
  }, [status, sendCommand]);

  return null;
}

export default function App() {
  const token = use(tokenPromise);

  return (
    <ReactorProvider modelName="reactor/helios" jwtToken={token} connectOptions={{ autoConnect: true }}>
      <ReactorView className="w-full aspect-video" />
      <AutoStart />
    </ReactorProvider>
  );
}

import asyncio
import os
from reactor_sdk import Reactor, ReactorStatus

async def main():
    reactor = Reactor(
        model_name="reactor/helios",
        api_key=os.environ["REACTOR_API_KEY"],
    )

    # Helios stays idle until it has a prompt and a start command.
    @reactor.on_status(ReactorStatus.READY)
    async def on_ready(status):
        output = reactor.tracks.with_direction("recvonly").with_kind("video").one()

        @output.on_frame
        def on_frame(frame):
            # (H, W, 3) uint8 RGB
            print(f"Frame: {frame.shape}")

        await reactor.send_command("set_prompt", {"prompt": "A serene mountain landscape at sunrise"})
        await reactor.send_command("start", {})

    await reactor.connect()
    await asyncio.Event().wait()  # run until interrupted

asyncio.run(main())

import Foundation
import Reactor

let reactor = try await Reactor(model: "reactor/helios", apiKey: ProcessInfo.processInfo.environment["REACTOR_API_KEY"]!)

let status = reactor.onStatus { s in
    guard s == .ready else { return }
    Task {
        try await reactor.sendCommand("set_prompt", ["prompt": "A serene mountain landscape at sunrise"])
        try await reactor.sendCommand("start")
    }
}

try await reactor.connect()

// Could just as well be registered before connect() — Swift accepts any
// track name until the session declares its tracks.
let output = try reactor.track("main_video")
let frames = try output.onFrame { frame in
    print("Frame: \(frame.width)x\(frame.height)")
}

try await Task.sleep(for: .seconds(30))  // run for a while
try await reactor.disconnect()

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>example</groupId>
  <artifactId>reactor-quickstart</artifactId>
  <version>1.0.0</version>
  <properties>
    <maven.compiler.release>22</maven.compiler.release>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>
  <dependencies>
    <dependency>
      <groupId>inc.reactor</groupId>
      <artifactId>reactor-sdk</artifactId>
      <version>1.0.0</version>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.14.0</version>
      </plugin>
    </plugins>
  </build>
</project>

import inc.reactor.sdk.*;

public class Main {
    public static void main(String[] args) throws Exception {
        String apiUrl = "https://api.reactor.inc";
        String jwt = Reactor.fetchJwt(apiUrl, System.getenv("REACTOR_API_KEY"),
                JsonValue.parse("""
                    {"models": ["reactor/helios"], "max_sessions": 1}
                    """), false).join();

        try (Reactor reactor = Reactor.open(ReactorOptions
                .builder(apiUrl, "reactor/helios").jwt(jwt).build())) {
            try {
                reactor.connect().join();
                try (Subscription frames = reactor.track("main_video").onFrame((VideoFrame frame) -> {
                    System.out.printf("Frame: %dx%d%n", frame.width(), frame.height());
                })) {
                    reactor.sendCommand("set_prompt", JsonValue.object()
                            .put("prompt", "A serene mountain landscape at sunrise").build()).join();
                    reactor.sendCommand("start").join();
                    Thread.sleep(30_000);
                }
            } finally {
                reactor.disconnect().join();
            }
        }
    }
}