npm install videorouter-live

pnpm add videorouter-live

yarn add videorouter-live

import { LiveVideo } from "videorouter-live";

const lv = new LiveVideo({ apiKey: process.env.VIDEOROUTER_API_KEY });

// Your server, per page load / per user. The token is safe to hand to a browser.
const { token } = await lv.createToken({
  models: ["fal/happy-oyster-adventure"],
  expiresIn: 300,                                  // seconds
  maxSessions: 1,
  maxSessionDurationSeconds: 60,
});
res.json({ token });                               // e.g. from your /api/live-token route

import { LiveVideo } from "videorouter-live";

// tokenProvider is called for the first request and once more if the token has expired (401).
const lv = new LiveVideo({
  tokenProvider: async () => (await fetch("/api/live-token", { method: "POST" }).then((r) => r.json())).token,
});

const session = await lv.createSession({
  model: "fal/happy-oyster-adventure",
  maxDurationSeconds: 60,
  options: { world: { prompt: "a rainy cyberpunk city", perspective: "first_person" } },
});
session.on("statusChanged", (status) => console.log(status));   // waiting -> ready -> ended

await session.waitUntilReady();      // a world takes ~30-120 s to build; nothing is metered while "waiting"
session.startHeartbeat();            // every ~5 s in the background

startHostStream(session.connect);    // hand the host credentials to the host's own SDK (below)

// ... when the user is done:
await session.end();
console.log(session.billedSeconds, session.costUsd, session.endReason);

import { LiveVideo } from "videorouter-live";

const lv = new LiveVideo({ apiKey: process.env.VIDEOROUTER_API_KEY });

// open -> wait until ready -> heartbeat -> your code -> settle (in a finally)
const result = await lv.withSession(
  { model: "decart/lucy-2.5", maxDurationSeconds: 120, options: { speed: "standard" } },
  async (session) => {
    await sendToBrowser(session.connect);      // host credentials - returned once
    return await waitForUserToFinish();
  },
);

const s = await lv.createSession({
  model: "fal/happy-oyster-adventure",
  maxDurationSeconds: 60,
  options: { world: { prompt: "x", perspective: "third_person" } },
});
console.log(s.status);                         // "waiting" - a world is building, nothing is metered

s.on("statusChanged", (st) => console.log("->", st));
s.once("ended", (sess) => console.log("settled:", sess.costUsd));
s.on("error", (e) => console.warn("heartbeat problem:", e.code));

await s.waitUntilReady({ timeout: 180_000, pollInterval: 4_000 });   // the poll that sees it ready returns s.connect
s.startHeartbeat();                            // setInterval, unref()'d in Node
use(s.connect);

await s.end({ hostTravelId: "..." });          // optional (Happy Oyster): bill on the host's own duration + fetch the replay

import { HappyOysterModel } from "videorouter-live";

const happyOyster = new HappyOysterModel({ mode: "adventure", videoElement });
await happyOyster.connect(token);          // a browser token from lv.createToken() on your server

// Describe the world
await happyOyster.createWorld({ prompt: "A sunlit meadow with an old oak." });

// Start streaming
await happyOyster.startTravel();
happyOyster.sendCommand({ translation: "Front" });

await happyOyster.end();                   // stops the stream, then settles the session

import { LucyModel } from "videorouter-live";

const lucy = new LucyModel({ model: "decart/lucy-2.5" });
await lucy.connect(token);

const stream = await navigator.mediaDevices.getUserMedia({ video: true });
await lucy.start(stream, { prompt: "Anime style", onRemoteStream: (s) => (video.srcObject = s) });
lucy.setPrompt("Cyberpunk");               // change the edit on the fly
await lucy.end();

import { OdysseyModel } from "videorouter-live";

const odyssey = new OdysseyModel();
await odyssey.connect(token);
await odyssey.start({ prompt: "A cat walking through a neon city" });
odyssey.interact("make it rain");
await odyssey.end();

import { ViduAvatarModel } from "videorouter-live";

// Needs Alibaba Cloud RTC in the page: `npm i aliyun-rtc-sdk`, or load its CDN script, or pass { hostSdk: { AliRtcEngine } }.
const tina = new ViduAvatarModel({ callMode: "video" });       // or "audio"
await tina.connect(token);
await tina.start({
  persona: "You are Tina, a friendly product guide.",
  imageUri: "https://example.com/tina.png",
  voice: "Tina",
  videoElement: document.getElementById("character"),   // her video
  previewElement: document.getElementById("me"),
});
tina.say("Hi! What can you show me?");                  // she answers in audio and video
tina.interrupt();                                       // cut her off mid-sentence
await tina.end();                                       // hangs up, then settles

import { ViduEditingModel } from "videorouter-live";

const edit = new ViduEditingModel({ editingType: "virtual_tryon" });
await edit.connect(token);
await edit.start({ imageUrl: "https://example.com/jacket.png", videoElement: document.getElementById("result") });
edit.switchPrompt({ imageUrl: "https://example.com/coat.png" });   // no ack on success; each call is a real switch
edit.switchPrompt({ editingType: "background_replacement" });
await edit.end();

import { ViduComponentAvatarModel } from "videorouter-live";
import WebSocket from "ws";                       // server: a WebSocket that accepts headers (an API key never goes in a URL)

const tina = new ViduComponentAvatarModel({ webSocket: WebSocket });
await tina.connect({ apiKey: process.env.VIDEOROUTER_API_KEY });   // in a browser: connect(token) and omit webSocket
await tina.start({
  imageUri: "https://example.com/tina.png",
  rtcInfo: { provider: "agora", app_id, channel_id, user_id, token },   // omit it and Vidu hosts a channel: tina.managedRtc
});
tina.sendAudio(pcmChunk);                // raw PCM, 16-bit signed little-endian, 24 kHz, mono
tina.sendUserText("What time is it?");   // what the user said (your ASR)
tina.sendReplyText("It is noon.");       // what your model answered
tina.interrupt();                        // the user started talking over her
await tina.end();                        // hangs up and settles; closing the stream does the same

import { LiveVideo } from "videorouter-live";

const lv = new LiveVideo();                // reads VIDEOROUTER_API_KEY

// Create and wait
const job = await lv.videos.generate({
  model: "heygen-video-1",
  prompt: "A presenter says: 'Welcome to VideoRouter.'",
  duration_secs: 5,
});
console.log(job.url);

// Or step by step
const queued = await lv.videos.create({ model: "wan-3.0-prime", prompt: "A robotic arm in a lab" });
await queued.wait({ timeout: 600_000, pollInterval: 5_000 });   // throws VideoGenerationError / TimeoutError
const again = await lv.videos.get(queued.id);

import { InsufficientCreditsError, ConcurrencyLimitError, HostCapacityError, PricingUnavailableError, LiveVideoError } from "videorouter-live";

try {
  await lv.createSession({ model: "fal/happy-oyster-adventure", maxDurationSeconds: 60 });
} catch (e) {
  if (e instanceof InsufficientCreditsError) { /* top up, or book fewer seconds */ }
  else if (e instanceof ConcurrencyLimitError) { /* end a session first; e.retryAfter is set */ }
  else if (e instanceof HostCapacityError) { await sleep((e.retryAfter ?? 5) * 1000); }
  else if (e instanceof PricingUnavailableError) { /* model.available === false */ }
  else if (e instanceof LiveVideoError) { console.log(e.status, e.code, e.message); }
  else throw e;
}

import { LiveVideo, type LiveSession, type Model, type SessionStatus } from "videorouter-live";

const lv = new LiveVideo({ token });
const models: Model[] = await lv.models();
const bookable = models.filter((m) => m.available && m.kind === "world");

const session: LiveSession = await lv.createSession({ model: bookable[0].id });
session.on("statusChanged", (status: SessionStatus) => {});
// session.on("frame", ...)   // type error: not an event

import { LiveVideo } from "videorouter-live";

const lv = new LiveVideo({
  apiKey: "test",
  baseUrl: "http://test/v1",
  fetch: async () => new Response(JSON.stringify({ object: "list", data: [] }), { status: 200 }),
});
console.assert((await lv.models()).length === 0);