Visko Orbis Stable schema reference

const reply = await reactor.sendCommand("set_prompt", {
  prompt:
    "A dramatic coastline of black volcanic cliffs at golden hour, huge dark waves rolling in from a blood-orange sea. Cinematic slow aerial motion, a single unbroken take.",
});
// reply === { type: "prompt_accepted", data: { prompt: "A dramatic coastline…" } }

const { setPrompt } = useViskoOrbisStable();
const reply = await setPrompt({
  prompt:
    "A dramatic coastline of black volcanic cliffs at golden hour, huge dark waves rolling in from a blood-orange sea. Cinematic slow aerial motion, a single unbroken take.",
});
// reply === { type: "prompt_accepted", data: { prompt: "A dramatic coastline…" } }

reply = await reactor.send_command("set_prompt", {
    "prompt": "A dramatic coastline of black volcanic cliffs at golden hour, huge dark waves rolling in from a blood-orange sea. Cinematic slow aerial motion, a single unbroken take.",
})
# reply == {"type": "prompt_accepted", "data": {"prompt": "A dramatic coastline…"}}

const reply = await reactor.sendCommand("set_audio_prompt", {
  prompt:
    "Acoustic guitar strums a rhythmic melody, with soft finger noise on the strings and quiet room ambience.",
});
// reply === { type: "audio_prompt_accepted", data: { audio_prompt: "Acoustic guitar…" } }

const { setAudioPrompt } = useViskoOrbisStable();
const reply = await setAudioPrompt({ prompt: "" });
// reply === { type: "audio_prompt_accepted", data: { audio_prompt: null } }

reply = await reactor.send_command("set_audio_prompt", {"prompt": ""})
# reply == {"type": "audio_prompt_accepted", "data": {"audio_prompt": None}}

const ref = await reactor.uploadFile(seedImageFile);
const reply = await reactor.sendCommand("set_image", { image: ref });
// reply === { type: "image_accepted", data: { width: 832, height: 480 } }

const { uploadFile, setImage } = useViskoOrbisStable();
const ref = await uploadFile(seedImageFile);
const reply = await setImage({ image: ref });
// reply === { type: "image_accepted", data: { width: 832, height: 480 } }

ref = await reactor.upload_file("seed.png")
reply = await reactor.send_command("set_image", {"image": ref})
# reply == {"type": "image_accepted", "data": {"width": 832, "height": 480}}

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

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

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

const reply = await reactor.sendCommand("set_resolution", { resolution: "2k" });
// reply === { type: "resolution_accepted", data: { width: 832, height: 480, resolution: "2k" } }

const { setResolution } = useViskoOrbisStable();
const reply = await setResolution({ resolution: "2k" });
// reply === { type: "resolution_accepted", data: { width: 832, height: 480, resolution: "2k" } }

reply = await reactor.send_command("set_resolution", {"resolution": "2k"})
# reply == {"type": "resolution_accepted", "data": {"width": 832, "height": 480, "resolution": "2k"}}

const reply = await reactor.sendCommand("set_audio_enabled", { audio_enabled: false });
// reply === { type: "audio_enabled_accepted", data: { audio_enabled: false } }

const { setAudioEnabled } = useViskoOrbisStable();
const reply = await setAudioEnabled({ audio_enabled: false });
// reply === { type: "audio_enabled_accepted", data: { audio_enabled: false } }

reply = await reactor.send_command("set_audio_enabled", {"audio_enabled": False})
# reply == {"type": "audio_enabled_accepted", "data": {"audio_enabled": False}}

const started = await reactor.sendCommand("start", {});
// started === { type: "generation_started", data: { fps: 24, width: 832, height: 480, … } }
const paused = await reactor.sendCommand("pause", {});
// paused === { type: "generation_paused", data: { chunk_index: 3 } }
const resumed = await reactor.sendCommand("resume", {});
// resumed === { type: "generation_resumed", data: { chunk_index: 3 } }
const reset = await reactor.sendCommand("reset", {});
// reset === { type: "generation_reset", data: { reason: "client_reset" } }

const { start, pause, resume, reset } = useViskoOrbisStable();
// Each resolves with the correlated reply, e.g.:
// const started = await start();  // → { type: "generation_started", data: {…} }

started = await reactor.send_command("start", {})
# started == {"type": "generation_started", "data": {"fps": 24, "width": 832, "height": 480, …}}
paused = await reactor.send_command("pause", {})
# paused == {"type": "generation_paused", "data": {"chunk_index": 3}}
resumed = await reactor.send_command("resume", {})
# resumed == {"type": "generation_resumed", "data": {"chunk_index": 3}}
reset = await reactor.send_command("reset", {})
# reset == {"type": "generation_reset", "data": {"reason": "client_reset"}}

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

import {
  useViskoOrbisStableState,
  useViskoOrbisStableCommandError,
} from "@reactor-models/visko-orbis-stable";

function StateReadout() {
  useViskoOrbisStableState((s) =>
    console.log(`chunk ${s.current_chunk} · ${s.current_prompt ?? ""}`),
  );
  useViskoOrbisStableCommandError((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']} · {data.get('current_prompt') or ''}")
    elif msg["type"] == "command_error":
        print(f"{data['command']} rejected: {data['reason']}")

import { ViskoOrbisStableModel } from "@reactor-models/visko-orbis-stable";

const visko = new ViskoOrbisStableModel();

visko.onChunkComplete(({ chunk_index, active_prompt }) => {
  console.log(`chunk ${chunk_index}: ${active_prompt.slice(0, 40)}…`);
});
// Broadcasts only — command acks are read off the awaited call, not this listener.
visko.onCommandError(({ command, reason }) => {
  console.error(`${command} rejected: ${reason}`);
});

await visko.connect(jwt);

// Text-to-video start — no image. If you set one, wait for image_accepted.
await visko.setPrompt({
  prompt:
    "A dramatic coastline of black volcanic cliffs at golden hour, huge dark waves rolling in from a blood-orange sea. Cinematic slow aerial motion, a single unbroken take.",
});
await visko.start();

// Live steering — the hero feature. The picture morphs at the next chunk
// boundary; no start, no reset, no ack wait.
await visko.setPrompt({
  prompt:
    "The same black volcanic coastline, the same slow aerial camera hugging the cliffs. The sunset is gone — towering charcoal storm clouds now swallow the sky, the waves grow massive and dark. Elemental, dangerous, photorealistic — a single unbroken take.",
});

import asyncio, os
from reactor_sdk import Reactor

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

    await reactor.connect()

    await reactor.send_command("set_prompt", {
        "prompt": "A dramatic coastline of black volcanic cliffs at golden hour, huge dark waves rolling in from a blood-orange sea. Cinematic slow aerial motion, a single unbroken take.",
    })
    await reactor.send_command("start", {})

    # Live steering — morphs on the next chunk boundary.
    await reactor.send_command("set_prompt", {
        "prompt": "The same black volcanic coastline, the same slow aerial camera hugging the cliffs. The sunset is gone — towering charcoal storm clouds now swallow the sky. Elemental, dangerous, photorealistic — a single unbroken take.",
    })

    await asyncio.Event().wait()

asyncio.run(main())