LingBot World 2 schema reference

await reactor.sendCommand("set_prompt", {
  prompt: "A reddish-brown ant on a dirt path between tall green grass blades, macro nature.",
});

const { setPrompt } = useLingbotWorld2();
await setPrompt({
  prompt: "A reddish-brown ant on a dirt path between tall green grass blades, macro nature.",
});

await reactor.send_command("set_prompt", {
    "prompt": "A reddish-brown ant on a dirt path between tall green grass blades, macro nature.",
})

const ref = await reactor.uploadFile(seedImageFile);
await reactor.sendCommand("set_image", { image: ref });

const { uploadFile, setImage } = useLingbotWorld2();
const ref = await uploadFile(seedImageFile);
await setImage({ image: ref });

ref = await reactor.upload_file("seed.png")
await reactor.send_command("set_image", {"image": ref})

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

const { setSeed } = useLingbotWorld2();
await setSeed({ seed: 42 });

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

await reactor.sendCommand("set_move_longitudinal", { move_longitudinal: "forward" });

// The value persists across chunks; idle it to stop.
await reactor.sendCommand("set_move_longitudinal", { move_longitudinal: "idle" });

const { setMoveLongitudinal } = useLingbotWorld2();
await setMoveLongitudinal({ move_longitudinal: "forward" });

await reactor.send_command("set_move_longitudinal", {"move_longitudinal": "forward"})

// Combine with longitudinal for a diagonal (W+A).
await reactor.sendCommand("set_move_lateral", { move_lateral: "strafe_left" });

const { setMoveLateral } = useLingbotWorld2();
await setMoveLateral({ move_lateral: "strafe_left" });

await reactor.send_command("set_move_lateral", {"move_lateral": "strafe_left"})

await reactor.sendCommand("set_look_horizontal", { look_horizontal: "left" });

const { setLookHorizontal } = useLingbotWorld2();
await setLookHorizontal({ look_horizontal: "left" });

await reactor.send_command("set_look_horizontal", {"look_horizontal": "left"})

await reactor.sendCommand("set_look_vertical", { look_vertical: "up" });

const { setLookVertical } = useLingbotWorld2();
await setLookVertical({ look_vertical: "up" });

await reactor.send_command("set_look_vertical", {"look_vertical": "up"})

await reactor.sendCommand("set_rotation_speed_deg", { rotation_speed_deg: 10.0 });

const { setRotationSpeedDeg } = useLingbotWorld2();
await setRotationSpeedDeg({ rotation_speed_deg: 10.0 });

await reactor.send_command("set_rotation_speed_deg", {"rotation_speed_deg": 10.0})

// Constant-velocity orbit: steady yaw with a lateral counter-drift.
await reactor.sendCommand("set_camera_pose", { camera_pose: [0, 0.04, 0, -0.35, 0, 0] });

// Hand the camera back to the look axes.
await reactor.sendCommand("set_camera_pose", { camera_pose: [] });

const { setCameraPose } = useLingbotWorld2();
await setCameraPose({ camera_pose: [0, 0.04, 0, -0.35, 0, 0] });
await setCameraPose({ camera_pose: [] });

await reactor.send_command("set_camera_pose", {"camera_pose": [0, 0.04, 0, -0.35, 0, 0]})
await reactor.send_command("set_camera_pose", {"camera_pose": []})

await reactor.sendCommand("set_attn_window", { attn_window: "large" });

const { setAttnWindow } = useLingbotWorld2();
await setAttnWindow({ attn_window: "large" });

await reactor.send_command("set_attn_window", {"attn_window": "large"})

await reactor.sendCommand("set_kv_cache_reset", { mode: "manual" });

const { setKvCacheReset } = useLingbotWorld2();
await setKvCacheReset({ mode: "manual" });

await reactor.send_command("set_kv_cache_reset", {"mode": "manual"})

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

const { triggerKvCacheReset } = useLingbotWorld2();
await triggerKvCacheReset();

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

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

const { start, pause, resume, reset } = useLingbotWorld2();

await reactor.send_command("start", {})
await reactor.send_command("pause", {})
await reactor.send_command("resume", {})
await reactor.send_command("reset", {})

reactor.on("message", (msg) => {
  switch (msg.type) {
    case "state":
      console.log(`chunk ${msg.data.current_chunk} · action ${msg.data.current_action}`);
      break;
    case "generation_started":
      console.log(`run: ${msg.data.chunk_num} chunks`);
      break;
    case "command_error":
      console.error(`${msg.data.command} rejected: ${msg.data.reason}`);
      break;
  }
});

import {
  useLingbotWorld2State,
  useLingbotWorld2CommandError,
} from "@reactor-models/lingbot-world-2";

function StateReadout() {
  useLingbotWorld2State((s) => console.log(`chunk ${s.current_chunk} · ${s.current_action}`));
  useLingbotWorld2CommandError((e) => console.error(`${e.command} rejected: ${e.reason}`));
  return null;
}

@reactor.on_message
def handle(msg):
    data = msg["data"]
    if msg["type"] == "state":
        print(f"chunk {data['current_chunk']} · action {data['current_action']}")
    elif msg["type"] == "command_error":
        print(f"{data['command']} rejected: {data['reason']}")

import { LingbotWorld2Model } from "@reactor-models/lingbot-world-2";

const lingbot = new LingbotWorld2Model();

lingbot.onChunkComplete(({ chunk_index, active_action }) => {
  console.log(`chunk ${chunk_index}: ${active_action}`);
});
lingbot.onCommandError(({ command, reason }) => {
  console.error(`${command} rejected: ${reason}`);
});

await lingbot.connect(jwt);

// Wait for the seed image to decode so the first chunk renders from it.
const imageAccepted = new Promise<void>((resolve) => lingbot.onImageAccepted(() => resolve()));
const ref = await lingbot.uploadFile(seedImageFile);
await lingbot.setImage({ image: ref });
await imageAccepted;

await lingbot.setPrompt({
  prompt: "A reddish-brown ant on a dirt path between tall green grass blades, macro nature.",
});
await lingbot.start();

// Drive the camera. Movement is two independent axes, so W+A is diagonal.
await lingbot.setMoveLongitudinal({ move_longitudinal: "forward" });
await lingbot.setMoveLateral({ move_lateral: "strafe_left" });

import asyncio, os
from reactor_sdk import Reactor

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

    image_accepted = asyncio.Event()

    @reactor.on_message("image_accepted")
    def _(msg):
        image_accepted.set()

    await reactor.connect()

    ref = await reactor.upload_file("seed.png")
    await reactor.send_command("set_image", {"image": ref})
    await image_accepted.wait()

    await reactor.send_command("set_prompt", {
        "prompt": "A reddish-brown ant on a dirt path between tall green grass blades, macro nature.",
    })
    await reactor.send_command("start", {})

    # Drive the camera.
    await reactor.send_command("set_move_longitudinal", {"move_longitudinal": "forward"})
    await asyncio.Event().wait()

asyncio.run(main())