X2 Schema Reference

await reactor.sendCommand("set_prompt", {
  prompt: "replace the character in the video with the character from the reference image",
});

const { setPrompt } = useX2();
await setPrompt({
  prompt: "replace the character in the video with the character from the reference image",
});

await reactor.send_command("set_prompt", {
    "prompt": "replace the character in the video with the character from the reference image",
})

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

const { uploadFile, setReferenceImage } = useX2();
const ref = await uploadFile(imageFile);
await setReferenceImage({ reference_image: ref });

ref = await reactor.upload_file("character.jpg")
await reactor.send_command("set_reference_image", {"reference_image": ref})

// Drag in progress at the frame's center-right.
await reactor.sendCommand("set_pointer", { x: 0.8, y: 0.5, active: true });

// Release: the pointer stops steering.
await reactor.sendCommand("set_pointer", { x: 0.8, y: 0.5, active: false });

const { setPointer } = useX2();
await setPointer({ x: 0.8, y: 0.5, active: true });
await setPointer({ active: false });

await reactor.send_command("set_pointer", {"x": 0.8, "y": 0.5, "active": True})
await reactor.send_command("set_pointer", {"active": False})

await reactor.sendCommand("set_pointer_x", { pointer_x: 0.25 });
await reactor.sendCommand("set_pointer_active", { pointer_active: true });

const { setPointerX, setPointerActive } = useX2();
await setPointerX({ pointer_x: 0.25 });
await setPointerActive({ pointer_active: true });

await reactor.send_command("set_pointer_x", {"pointer_x": 0.25})
await reactor.send_command("set_pointer_active", {"pointer_active": True})

await reactor.sendCommand("set_keep_backlog", { keep_backlog: true });

const { setKeepBacklog } = useX2();
await setKeepBacklog({ keep_backlog: true });

await reactor.send_command("set_keep_backlog", {"keep_backlog": True})

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

const { reset } = useX2();
await reset();

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

reactor.on("message", (msg) => {
  switch (msg.type) {
    case "state_update":
      console.log(`generating: ${msg.data.generating} · prompt: ${msg.data.prompt}`);
      break;
    case "generation_started":
      console.log(`output: ${msg.data.width}x${msg.data.height}`);
      break;
    case "command_error":
      console.error(`${msg.data.command} rejected: ${msg.data.reason}`);
      break;
  }
});

import { useX2StateUpdate, useX2CommandError } from "@reactor-models/x2";

function StateReadout() {
  useX2StateUpdate((s) => console.log(`generating: ${s.generating} · prompt: ${s.prompt}`));
  useX2CommandError((e) => console.error(`${e.command} rejected: ${e.reason}`));
  return null;
}

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

import { X2Model } from "@reactor-models/x2";

const x2 = new X2Model();

x2.onGenerationStarted(({ width, height, has_reference_image }) => {
  console.log(`run started at ${width}x${height}, reference: ${has_reference_image}`);
});
x2.onCommandError(({ command, reason }) => {
  console.error(`${command} rejected: ${reason}`);
});
x2.onMainVideo((track, stream) => {
  video.srcObject = stream;
  void video.play();
});

await x2.connect(jwt);

// Publish the stream to edit.
const media = await navigator.mediaDevices.getUserMedia({ video: true });
await x2.publishSource(media.getVideoTracks()[0]);

// Anchor the swap to a reference image, then arm generation with a prompt.
const ref = await x2.uploadFile(characterImageFile);
await x2.setReferenceImage({ reference_image: ref });
await x2.setPrompt({
  prompt: "replace the character in the video with the character from the reference image",
});
// No start command: generation begins now that a prompt is set and frames are flowing.

// Steer the subject with a short drag to the right.
await x2.setPointer({ x: 0.5, y: 0.5, active: true });
await x2.setPointer({ x: 0.8, y: 0.5, active: true });
await x2.setPointer({ x: 0.8, y: 0.5, active: false });

import asyncio, os
from reactor_sdk import Reactor

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

    @reactor.on_message("generation_started")
    def _(msg):
        d = msg["data"]
        print(f"run started at {d['width']}x{d['height']}")

    await reactor.connect()

    ref = await reactor.upload_file("character.jpg")
    await reactor.send_command("set_reference_image", {"reference_image": ref})
    await reactor.send_command("set_prompt", {
        "prompt": "replace the character in the video with the character from the reference image",
    })

    # Steer with a short drag.
    await reactor.send_command("set_pointer", {"x": 0.5, "y": 0.5, "active": True})
    await reactor.send_command("set_pointer", {"x": 0.8, "y": 0.5, "active": True})
    await reactor.send_command("set_pointer", {"x": 0.8, "y": 0.5, "active": False})
    await asyncio.Event().wait()

asyncio.run(main())