LTX schema reference

const ref = await reactor.uploadFile(imageFile);
await reactor.sendCommand("set_avatar_image", { avatar_image: ref });

const { uploadFile, setAvatarImage } = useLtx2();

const ref = await uploadFile(imageFile);
await setAvatarImage({ avatar_image: ref });

ref = await reactor.upload_file(image_file)
await reactor.send_command("set_avatar_image", {"avatar_image": ref})

await reactor.sendCommand("set_script", { script: "Hello from LTX." });

const { setScript } = useLtx2();

await setScript({ script: "Hello from LTX." });

await reactor.send_command("set_script", {"script": "Hello from LTX."})

await reactor.sendCommand("set_prompt", {
  prompt: "News anchor at a desk, professional tone, warm studio lighting",
});

const { setPrompt } = useLtx2();

await setPrompt({
  prompt: "News anchor at a desk, professional tone, warm studio lighting",
});

await reactor.send_command("set_prompt", {
    "prompt": "News anchor at a desk, professional tone, warm studio lighting",
})

await reactor.sendCommand("set_wpm", { wpm: 170 });

const { setWpm } = useLtx2();

await setWpm({ wpm: 170 });

await reactor.send_command("set_wpm", {"wpm": 170})

await reactor.sendCommand("set_duration_seconds", { duration_seconds: 30 });

const { setDurationSeconds } = useLtx2();

await setDurationSeconds({ duration_seconds: 30 });

await reactor.send_command("set_duration_seconds", {"duration_seconds": 30})

await reactor.sendCommand("set_seed", { seed: 7 });

const { setSeed } = useLtx2();

await setSeed({ seed: 7 });

await reactor.send_command("set_seed", {"seed": 7})

await reactor.sendCommand("start", {});

const { start } = useLtx2();

await start();

await reactor.send_command("start", {})

await reactor.sendCommand("pause", {});

const { pause } = useLtx2();

await pause();

await reactor.send_command("pause", {})

await reactor.sendCommand("resume", {});

const { resume } = useLtx2();

await resume();

await reactor.send_command("resume", {})

await reactor.sendCommand("stop", {});

const { stop } = useLtx2();

await stop();

await reactor.send_command("stop", {})

await reactor.sendCommand("reset", {});

const { reset } = useLtx2();

await reset();

await reactor.send_command("reset", {})

reactor.on("message", (msg) => {
  if (msg.type === "state_update") {
    console.log(msg.data.valid_commands);
  }
});

useLtx2StateUpdate((msg) => {
  console.log(msg.valid_commands);
});

reactor.on("message", (msg) => {
  switch (msg.type) {
    case "state_update":
      // The snapshot is the source of truth, so render controls from it.
      updateButtons(msg.data.valid_commands);
      progressEl.textContent = `${msg.data.seconds_sent.toFixed(1)}s / ${msg.data.effective_seconds}s`;
      break;
    case "window_progress":
      console.log(`Window ${msg.data.window_index + 1}/${msg.data.total_windows}`);
      break;
    case "generation_complete":
      console.log(`Take finished after ${msg.data.seconds_sent}s`);
      break;
    case "command_error":
      console.error(`${msg.data.command} rejected: ${msg.data.reason}`);
      break;
  }
});

// One typed hook per message; payload fields sit directly on the message.
useLtx2StateUpdate((msg) => {
  updateButtons(msg.valid_commands);
  setProgress(`${msg.seconds_sent.toFixed(1)}s / ${msg.effective_seconds}s`);
});

useLtx2WindowProgress((msg) => {
  console.log(`Window ${msg.window_index + 1}/${msg.total_windows}`);
});

useLtx2GenerationComplete((msg) => {
  console.log(`Take finished after ${msg.seconds_sent}s`);
});

useLtx2CommandError((msg) => {
  console.error(`${msg.command} rejected: ${msg.reason}`);
});

@reactor.on_message
def handle(msg):
    data = msg["data"]
    if msg["type"] == "state_update":
        print(f"Valid: {', '.join(data['valid_commands'])}")
        print(f"Sent {data['seconds_sent']:.1f}s of {data['effective_seconds']}s")
    elif msg["type"] == "window_progress":
        print(f"Window {data['window_index'] + 1}/{data['total_windows']}")
    elif msg["type"] == "generation_complete":
        print(f"Take finished after {data['seconds_sent']}s")
    elif msg["type"] == "command_error":
        print(f"{data['command']} rejected: {data['reason']}")

import { Reactor, FileRef } from "@reactor-team/js-sdk";

const reactor = new Reactor({ modelName: "reactor/ltx2" });

const videoElement = document.getElementById("video") as HTMLVideoElement;
const receivedTracks: MediaStreamTrack[] = [];

// Both tracks go into ONE MediaStream on ONE element, so video and
// audio stay on the same clock.
reactor.on("trackReceived", (name, track) => {
  if (name === "main_video" || name === "main_audio") {
    receivedTracks.push(track);
    videoElement.srcObject = new MediaStream(receivedTracks);
  }
});

reactor.on("message", (msg) => {
  if (msg.type === "state_update") {
    updateButtons(msg.data.valid_commands);
  }
  if (msg.type === "command_error") {
    console.error(`${msg.data.command} rejected: ${msg.data.reason}`);
  }
});

await reactor.connect(token); // see Authentication for how to obtain a token

const avatarImageRef: FileRef = await reactor.uploadFile(imageFile);
await reactor.sendCommand("set_avatar_image", { avatar_image: avatarImageRef });
await reactor.sendCommand("set_script", { script: "Hello from LTX." });
await reactor.sendCommand("set_prompt", { prompt: "News anchor at a desk, professional tone" });
await reactor.sendCommand("set_wpm", { wpm: 170 });
await reactor.sendCommand("set_seed", { seed: 7 });
await reactor.sendCommand("start", {});

import { useMemo, useEffect, useRef } from "react";
import { Ltx2Provider, useLtx2, useLtx2CommandError } from "@reactor-models/ltx2";

function App() {
  return (
    <Ltx2Provider getJwt={fetchToken}>
      <Take />
    </Ltx2Provider>
  );
}

function Take() {
  const { tracks, uploadFile, setAvatarImage, setScript, setPrompt, setWpm, setSeed, start } =
    useLtx2();

  useLtx2CommandError((msg) => {
    console.error(`${msg.command} rejected: ${msg.reason}`);
  });

  // Both tracks in ONE MediaStream on ONE element, so video and audio
  // stay on the same clock.
  const videoRef = useRef<HTMLVideoElement>(null);
  const stream = useMemo(() => {
    const list = [tracks["main_video"], tracks["main_audio"]].filter(Boolean);
    return list.length ? new MediaStream(list) : null;
  }, [tracks]);
  useEffect(() => {
    if (videoRef.current) videoRef.current.srcObject = stream;
  }, [stream]);

  async function generate(imageFile: File) {
    const ref = await uploadFile(imageFile);
    await setAvatarImage({ avatar_image: ref });
    await setScript({ script: "Hello from LTX." });
    await setPrompt({ prompt: "News anchor at a desk, professional tone" });
    await setWpm({ wpm: 170 });
    await setSeed({ seed: 7 });
    await start();
  }

  return <video ref={videoRef} autoPlay playsInline />;
}

import asyncio
import os
from reactor_sdk import Reactor

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

    @reactor.on_message
    def handle(msg):
        if msg["type"] == "command_error":
            print(f"{msg['data']['command']} rejected: {msg['data']['reason']}")

    await reactor.connect()

    with open("avatar.jpg", "rb") as f:
        avatar_image_ref = await reactor.upload_file(f)

    await reactor.send_command("set_avatar_image", {"avatar_image": avatar_image_ref})
    await reactor.send_command("set_script", {"script": "Hello from LTX."})
    await reactor.send_command("set_prompt", {"prompt": "News anchor at a desk, professional tone"})
    await reactor.send_command("set_wpm", {"wpm": 170})
    await reactor.send_command("set_seed", {"seed": 7})
    await reactor.send_command("start", {})

    await asyncio.Event().wait()

asyncio.run(main())