Using the SDK

The Reactor SDKs are how your app opens a session, sends commands, and receives video and events from any model:

JavaScript ships both a React API (provider, components, hooks) and an imperative API (the Reactor class). Use React for browser apps, imperative for vanilla JS or fine-grained control. The browser obtains a short-lived JWT token from your server.
Python is an async library for scripts, servers, and computer-vision pipelines. It receives frames as NumPy arrays and authenticates with your API key directly, server-side.
C++ is a C++17 library for native applications — engines, capture pipelines, desktop clients. Calls return std::future, frames arrive as BGRA on the library’s delivery thread, and it ships as a prebuilt archive per platform. See the C++ reference.
Swift is a Swift 6 package for macOS and iOS apps. Calls are async throws, frames arrive as BGRA Data on the library’s delivery thread, and it ships as a SwiftPM package — add the dependency and link. See the Swift reference.
Java is a Java 22+ library for JVM applications. Calls return CompletableFuture, and video frames arrive as borrowed BGRA pixels. See the Java reference.

The common examples below offer JavaScript, React, Python, C++, Swift, and Java. Pick a tab and it stays selected down the page. The native SDKs have their own full reference pages (C++ · Swift · Java).

Keep API keys on your server. Browser and distributed desktop or mobile apps obtain a short-lived JWT from your backend; trusted server applications can use an API key to obtain one. See Authentication.

Two layers: base SDK and typed SDKs

Reactor SDKs are built in two layers:

The base Reactor class is the generic, model-agnostic entry point. It speaks raw JSON over the wire: you call sendCommand(name, payload) and listen for generic message events. It works against any model. This page teaches the base layer, so the examples work no matter which model you connect to.
Typed SDKs (for example, HeliosModel) extend the base class and expose strongly-named methods (setPrompt(), sendImage(), …) that mirror a model’s schema. They add ergonomics, not capabilities, and every method is still a sendCommand() under the hood.

The base Reactor class sits at the top; typed model SDKs like HeliosModel and LingbotModel extend it

Reach for the base Reactor class when you’re experimenting with a model that has no typed SDK yet, developing locally against an in-progress model, writing a one-off script, or want a single SDK that can talk to several models. For everything else the typed SDK is the recommended path. See Typed model SDKs for the full story and the name-to-name mapping. For the commands and events a specific model accepts, see the Model API Reference.

Connecting

Connect

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

const reactor = new Reactor({ modelName: "your-model-name" });
await reactor.connect(token);

Disconnect when done:

Disconnect

await reactor.disconnect();

Wrap your app in ReactorProvider. Pass a token and the connection is managed automatically.

ReactorProvider

import { ReactorProvider, ReactorView } from "@reactor-team/js-sdk";

<ReactorProvider modelName="your-model-name" jwtToken={token}>
  <ReactorView className="w-full aspect-video" />
</ReactorProvider>;

The provider does not connect on mount by default. Pass connectOptions={{ autoConnect: true }} to connect immediately, or trigger it manually.

Manual connect

import { useReactor } from "@reactor-team/js-sdk";

function Controls() {
  const { connect, disconnect, status } = useReactor((s) => s);

  return status === "disconnected" ? (
    <button onClick={connect}>Connect</button>
  ) : (
    <button onClick={disconnect}>Disconnect</button>
  );
}

Connect

import asyncio
import os
from reactor_sdk import Reactor

async def main():
    reactor = Reactor(
        model_name="your-model-name",
        api_key=os.environ["REACTOR_API_KEY"],
    )

    await reactor.connect()
    await reactor.disconnect()

asyncio.run(main())

For automatic cleanup, use async with:

Context manager

from reactor_sdk import Reactor

async with Reactor(model_name="your-model-name", api_key=os.environ["REACTOR_API_KEY"]) as reactor:
    # disconnects automatically on exit
    pass

Connect

#include <reactor/reactor.hpp>

reactor::Reactor client{"your-model-name", reactor::ApiKey{std::getenv("REACTOR_API_KEY")}};
client.connect().get();

Disconnect when done:

Disconnect

client.disconnect().get();

Connect

import Reactor

let reactor = try await Reactor(model: "your-model-name", apiKey: apiKey)
try await reactor.connect()

Disconnect when done:

Disconnect

try await reactor.disconnect()

Install the Java SDK and native runtime first. Obtain jwt from your backend, then keep the client open while your application uses it:

Connect

import inc.reactor.sdk.Reactor;
import inc.reactor.sdk.ReactorOptions;

try (Reactor reactor = Reactor.open(
    ReactorOptions.builder("https://api.reactor.inc", "your-model-name")
        .jwt(jwt)
        .build())) {
    try {
        reactor.connect().join();
        // Send commands and receive frames here.
    } finally {
        reactor.disconnect().join();
    }
}

The finally block disconnects even if an operation fails, ending a session this client created. Try-with-resources then releases the client handle; closing the handle alone does not end the session. On a trusted server, obtain the JWT with Reactor.fetchJwt(apiUrl, apiKey).join(). Never embed the API key in a distributed app. join() blocks the calling thread; use future continuations on a UI thread.

See Authentication for how to obtain a token or API key.

Receiving model output

The browser SDK delivers the model’s video as a media track you render in a <video> element. Python delivers decoded frames as NumPy arrays for processing; C++, Swift, and Java deliver them as raw BGRA pixels.

Listen for the trackReceived event and attach the stream to a video element.

Track listener

const video = document.getElementById("video") as HTMLVideoElement;

reactor.on("trackReceived", (name, track, stream) => {
  video.srcObject = stream;
});

ReactorView displays the model’s video output automatically.

ReactorView

import { ReactorView } from "@reactor-team/js-sdk";

<ReactorView className="w-full aspect-video" videoObjectFit="cover" />;

Frames are delivered as NumPy arrays with shape (H, W, 3), dtype uint8, in RGB color order. They start arriving once the connection reaches READY and continue until you disconnect. Register on the Track — there is no client-wide on_frame, since a single handler fed every output track couldn’t tell them apart:

Frame handler

output = reactor.tracks.with_direction("recvonly").with_kind("video").one()

@output.on_frame
def render(frame):
    print(f"Frame: {frame.shape}")  # e.g. (768, 1280, 3)

Common uses:

Common uses

# Save with PIL
from PIL import Image
Image.fromarray(frame).save("frame.png")

# Process with OpenCV (convert RGB to BGR first)
import cv2
cv2.imwrite("frame.png", cv2.cvtColor(frame, cv2.COLOR_RGB2BGR))

# Run inference
result = my_model(frame)

Frames arrive as raw BGRA pixels, delivered inline on the library’s own thread. Register on the Track once the connection reaches Ready — registering earlier throws, since the session has not declared its tracks yet. There is no client-wide on_frame, since a single handler fed every output track couldn’t tell them apart:

Frame handler

auto output = client.track("main_video");
auto frames = output.on_frame([](const reactor::VideoFrame& frame) {
  std::cout << "Frame: " << frame.width << "x" << frame.height << '\n';
});

The pixels are borrowed for the duration of the handler and no longer — copy anything you keep. See VideoFrame.

Common uses:

Common uses

// Wrap as an OpenCV Mat — clone it, since frame.bgra is only valid inside this handler
cv::Mat bgra(frame.height, frame.width, CV_8UC4, const_cast<std::uint8_t*>(frame.bgra));
cv::Mat copy = bgra.clone();

// Convert to BGR for further processing
cv::Mat bgr;
cv::cvtColor(bgra, bgr, cv::COLOR_BGRA2BGR);

Frames arrive as raw BGRA Data, copied so they can be kept. Register on the Track any time — before or after connect() — since any track name is accepted until the session declares its tracks. There is no client-wide onFrame, since a single handler fed every output track couldn’t tell them apart:

Frame handler

let output = try reactor.track("main_video")
let frames = try output.onFrame { frame in
  print("Frame: \(frame.width)x\(frame.height)")
}

For a renderer that would rather not copy — uploading straight to a texture — onRawFrame(_:) hands the same fields borrowed, valid only for the duration of the handler.

Frame handler

import inc.reactor.sdk.VideoFrame;

var output = reactor.track("main_video");
var frames = output.onFrame((VideoFrame frame) -> {
    System.out.println("Frame: " + frame.width() + "x" + frame.height());
    byte[] bgra = frame.toByteArray(); // Copy pixels you need after this handler returns.
});

Video handlers run on the SDK’s media delivery thread. The frame’s pixels() memory is valid only inside the handler. Keep handlers short, and call frames.close() to unsubscribe. The explicit VideoFrame parameter distinguishes the video overload from the audio overload.

Sending commands

Commands control what the model does. The available commands depend on the model. See the Model API Reference. Wait for the connection to reach ready before sending commands; the model is not available until the connection is fully established.

Send command

reactor.on("statusChanged", async (status) => {
  if (status === "ready") {
    await reactor.sendCommand("set_prompt", { prompt: "a forest at dawn" });
  }
});

Send command

import { useReactor } from "@reactor-team/js-sdk";

function Controls() {
  const { sendCommand, status } = useReactor((s) => s);

  return (
    <button
      disabled={status !== "ready"}
      onClick={() => sendCommand("set_prompt", { prompt: "a forest at dawn" })}
    >
      Set prompt
    </button>
  );
}

Send command

from reactor_sdk import ReactorStatus

@reactor.on_status(ReactorStatus.READY)
async def on_ready(status):
    await reactor.send_command("set_prompt", {"prompt": "a forest at dawn"})

Send command

auto status = client.on_status([&client](reactor::Status s) {
  if (s == reactor::Status::Ready) {
    client.send_command("set_prompt", {{"prompt", "a forest at dawn"}});
  }
});

Send command

let status = reactor.onStatus { s in
  guard s == .ready else { return }
  Task { try await reactor.sendCommand("set_prompt", ["prompt": "a forest at dawn"]) }
}

After connect().join() completes:

Send command

import inc.reactor.sdk.JsonValue;

reactor.sendCommand("set_prompt",
    JsonValue.object().put("prompt", "a forest at dawn").build()).join();

The future returns an Optional<CommandReply>: it is empty when the command was acknowledged without a message.

File uploads

Upload files and pass them to commands. See File Uploads for the full guide.

File upload

const file = input.files[0];

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

File upload

import { useReactor } from "@reactor-team/js-sdk";

function ImageUpload() {
  const { uploadFile, sendCommand, status } = useReactor((s) => s);

  const handleFile = async (e: React.ChangeEvent<HTMLInputElement>) => {
    const file = e.target.files?.[0];
    if (!file) return;

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

  return <input type="file" accept="image/*" disabled={status !== "ready"} onChange={handleFile} />;
}

upload_file() accepts a file path, raw bytes, or a file-like object.

File upload

from reactor_sdk import Reactor, ReactorStatus

@reactor.on_status(ReactorStatus.READY)
async def on_ready(status):
    ref = await reactor.upload_file("photo.jpg")
    await reactor.send_command("set_image", {"image": ref})

Upload variants

# From a path (name and MIME type are inferred)
ref = await reactor.upload_file("photo.jpg")

# From bytes
ref = await reactor.upload_file(image_bytes, name="photo.jpg")

# From a file object
with open("photo.jpg", "rb") as f:
    ref = await reactor.upload_file(f)

File upload

auto ref = client.upload_file("photo.jpg").get();
client.send_command("set_image", {}, {{"image", ref}}).get();

Uploads are passed as a separate named parameter rather than embedded in args — there is no way to recognise a FileRef sitting inside a Json value.

File upload

let ref = try await reactor.uploadFile(at: photoURL)
try await reactor.sendCommand("set_image", uploads: ["image": ref])

Uploads are passed as a separate named parameter rather than embedded in args — the same reason as C++‘s: there is no way to recognise a FileRef sitting inside a JSONValue.

File upload

import inc.reactor.sdk.JsonValue;
import java.nio.file.Path;
import java.util.Map;

var ref = reactor.uploadFile(Path.of("photo.jpg")).join();
reactor.sendCommand("set_image", JsonValue.object().build(), Map.of("image", ref)).join();

Pass files in the separate uploads map, keyed by the command parameter. For in-memory data, use uploadBytes(imageBytes, "photo.jpg", "image/jpeg").

uploadFile() returns a FileRef (JavaScript · Python · C++ · Swift · Java) containing the upload ID, filename, MIME type, and size. Pass multiple FileRef values in a single command and mix them with scalar arguments like transition.

Receiving messages

Models can send structured messages back to your app, such as the current frame number, generation state, or custom events.

Message handler

reactor.on("message", (msg) => {
  if (msg.type === "state") {
    console.log("Frame:", msg.data.current_frame);
  }
});

Message handler

import { useReactorMessage } from "@reactor-team/js-sdk";

function StateDisplay() {
  const [frame, setFrame] = useState(0);

  useReactorMessage((msg) => {
    if (msg.type === "state") {
      setFrame(msg.data.current_frame);
    }
  });

  return <div>Frame: {frame}</div>;
}

Message handler

@reactor.on_message
def on_message(msg):
    if msg.get("type") == "state":
        print(f"Frame: {msg['data']['current_frame']}")

Using the event API directly:

Event API

def on_message(msg):
    print(msg)

reactor.on("message", on_message)
reactor.off("message", on_message)

Message handler

auto messages = client.on_message([](const reactor::Json& msg) {
  if (msg.value("type", "") == "state") {
    std::cout << "Frame: " << msg["data"]["current_frame"] << '\n';
  }
});

To unregister, hold the Subscription and call remove() — there is no off(event, handler), since two std::functions cannot be compared:

Unregistering

messages.remove();

Message handler

let messages = reactor.onMessage { msg in
  if msg["type"]?.stringValue == "state" {
    print("Frame: \(msg["data"]?["current_frame"] ?? "?")")
  }
}

To unregister, let the returned Subscription go out of scope, or call cancel() on it directly — there is no off(event:handler:), since two closures cannot be compared:

Unregistering

messages.cancel()

Message handler

import inc.reactor.sdk.JsonValue;

var messages = reactor.onMessage(msg -> {
    if (msg instanceof JsonValue.JsonObject object
            && object.getString("type").orElse("").equals("state")) {
        object.get("data").ifPresent(data -> System.out.println(data.toJsonString()));
    }
});

The returned subscription stays active until you close it or the client:

Unregistering

messages.close();

Sending video input

For models that accept a video input (e.g. video-to-video models), publish a track to the input declared by the model. Publishing is explicit: the model receives nothing until you publish, and connecting on its own never starts sending. Publish once the connection is ready, and call unpublishTrack() to stop.

Get a media stream and publish it once connected:

Publish track

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

const reactor = new Reactor({ modelName: "your-model-name" });

const stream = await navigator.mediaDevices.getUserMedia({ video: true });
const track = stream.getVideoTracks()[0];

reactor.on("statusChanged", async (status) => {
  if (status === "ready") {
    await reactor.publishTrack("webcam", track);
  }
});

await reactor.connect(token);

To stop publishing:

Unpublish

await reactor.unpublishTrack("webcam");
stream.getTracks().forEach((t) => t.stop());

Use WebcamStream and pass the name of the model’s input track:

WebcamStream

import { ReactorProvider, ReactorView, WebcamStream } from "@reactor-team/js-sdk";

<ReactorProvider modelName="your-model-name" jwtToken={token}>
  <ReactorView className="w-full aspect-video" />
  <WebcamStream track="webcam" className="w-48 aspect-video" />
</ReactorProvider>;

WebcamStream handles camera permissions, publishing when ready, and cleanup on unmount.

Activate the track slot the model declares, then push frames into it yourself — there is no MediaStreamTrack object in the Python SDK. reactor.track(name) returns an object scoped to that slot:

Publish track

from reactor_sdk import Reactor, ReactorStatus

reactor = Reactor(
    model_name="your-model-name",
    api_key=os.environ["REACTOR_API_KEY"],
)

@reactor.on_status(ReactorStatus.READY)
async def on_ready(status):
    webcam = await reactor.track("webcam").publish()

    while streaming:
        frame = capture_frame()  # RGB numpy array, or BGRA bytes + width/height
        webcam.push_frame(frame)
        await asyncio.sleep(1 / fps)

To stop publishing (synchronous, unlike the other track methods):

Unpublish

webcam.unpublish()

There is no media-device object in the C++ SDK either — publish the track slot, then push frames into it yourself:

Publish track

reactor::Reactor client{"your-model-name", reactor::ApiKey{std::getenv("REACTOR_API_KEY")}};

auto status = client.on_status([&client](reactor::Status s) {
  if (s != reactor::Status::Ready) return;

  auto webcam = client.track("webcam");
  webcam.publish().get();

  while (streaming) {
    auto [bgra, width, height] = capture_frame();
    webcam.push_frame({bgra.data(), bgra.size()}, width, height);
  }
});

client.connect().get();

To stop publishing (synchronous, unlike the other track methods):

Unpublish

webcam.unpublish();

There is no capture-device object in the Swift SDK either — publish the track slot, then push frames into it yourself:

Publish track

let reactor = try await Reactor(model: "your-model-name", apiKey: apiKey)

let status = reactor.onStatus { s in
  guard s == .ready else { return }
  Task {
    let webcam = try reactor.track("webcam")
    try await webcam.publish()

    while streaming {
      let (bgra, width, height) = captureFrame()
      try webcam.pushFrame(bgra, width: width, height: height)
    }
  }
}

try await reactor.connect()

To stop publishing (synchronous, unlike the other track methods):

Unpublish

try webcam.unpublish()

After connecting, publish the model’s input track, then push BGRA frames from your capture code:

Publish track

var webcam = reactor.track("webcam");
webcam.publish().join();
// bgra contains exactly width * height * 4 bytes from your capture source.
webcam.pushFrame(bgra, width, height);

Repeat pushFrame() at your source’s frame rate. The SDK does not capture a camera for you. Stop publishing synchronously:

Unpublish

webcam.unpublish();

The track name ("webcam") must match the attribute name declared on the model. The model declares which tracks it accepts in its capabilities, which are fetched automatically during connection.

In Python, a failed publish() does not clean up the session by itself — wrap the connected lifetime, publish included, in try/finally: await reactor.disconnect(), or a failure here can leave an orphaned session behind that the next connect() rejects with ConflictError.

Error handling

Handle connection and runtime errors from the SDK.

Error handler

reactor.on("error", (error) => {
  console.error(`${error.operation}: [${error.code}] ${error.message}`);

  if (error.recoverable) {
    reactor.reconnect();
  }
});

Error display

import { useReactor } from "@reactor-team/js-sdk";

function ErrorDisplay() {
  const lastError = useReactor((s) => s.lastError);

  if (!lastError) return null;

  return (
    <div>
      <strong>{lastError.code}</strong>: {lastError.message}
    </div>
  );
}

Error handler

from reactor_sdk import ReactorError

@reactor.on_error
def on_error(error: ReactorError):
    print(f"{error.operation}: [{error.code}] {error.message}")

    if error.recoverable:
        print(f"Retrying in {(error.retry_after_ms or 3000) / 1000}s")

Error handler

auto errors = client.on_error([&client](const reactor::ReactorError& error) {
  std::cerr << error.operation().value_or("") << ": [" << error.code() << "] "
            << error.message() << '\n';

  if (error.recoverable()) {
    client.reconnect();
  }
});

Error handler

let errors = reactor.onError { error in
  print("\(error.operation ?? ""): [\(error.code)] \(error.message)")

  if error.recoverable {
    Task { try await reactor.reconnect() }
  }
}

Error handler

var errors = reactor.onError(error -> {
    System.err.println(error.operation() + ": [" + error.code() + "] " + error.getMessage());
    if (error.isRecoverable()) {
        System.err.println("The connection can be retried.");
    }
});

Failed futures also carry a ReactorException. join() wraps it in CompletionException; inspect the cause when handling a failed operation.

See ReactorError (JavaScript · Python · C++ · Swift) for all error codes and fields. Java uses ReactorException.

Reconnection

If a connection drops unexpectedly, the session stays alive on the GPU for 30 seconds. Reconnect within that window to resume without losing server-side state. For more information, see Sessions.

Reconnect

// Terminate the session
await reactor.disconnect();

// Disconnect but keep the session alive on the server
await reactor.disconnect(true);
await reactor.reconnect();

Reconnect

import { useReactor } from "@reactor-team/js-sdk";

const { disconnect, reconnect } = useReactor((s) => s);

// Terminate the session
await disconnect();

// Disconnect but keep the session alive on the server
await disconnect(true);
await reconnect();

Reconnect

# disconnect() always terminates the session — there is no parameter to make
# it recoverable instead. To keep the session alive and resume it, call
# reconnect() directly; it tears the connection down itself, so don't
# disconnect() first.
await reactor.reconnect()

Reconnect

// disconnect() always terminates the session — there is no parameter to make
// it recoverable instead. To keep the session alive and resume it, call
// reconnect() directly; it tears the connection down itself, so don't
// disconnect() first.
client.reconnect().get();

Reconnect

// disconnect() always terminates the session — there is no parameter to make
// it recoverable instead. To keep the session alive and resume it, call
// reconnect() directly; it tears the connection down itself, so don't
// disconnect() first.
try await reactor.reconnect()

Reconnect

// Reconnect directly to preserve the session; disconnect() ends an owned session.
reactor.reconnect().join();

Reconnect resumes receiving tracks. Publish any input tracks again before sending more frames.

To reconnect automatically when the error is recoverable:

Auto-reconnect

reactor.on("error", (error) => {
  if (error.recoverable) {
    setTimeout(() => reactor.reconnect(), error.retry_after_ms ?? 3000);
  }
});

Auto-reconnect

import { useReactor } from "@reactor-team/js-sdk";

const { reconnect, lastError } = useReactor((s) => ({
  reconnect: s.reconnect,
  lastError: s.lastError,
}));

// Watch the store's lastError and reconnect when a recoverable error lands.
useEffect(() => {
  if (lastError?.recoverable) {
    const timer = setTimeout(() => reconnect(), lastError.retry_after_ms ?? 3000);
    return () => clearTimeout(timer);
  }
}, [lastError, reconnect]);

Auto-reconnect

from reactor_sdk import ReactorError

@reactor.on_error
async def on_error(error: ReactorError):
    if error.recoverable:
        await asyncio.sleep((error.retry_after_ms or 3000) / 1000)
        await reactor.reconnect()

Auto-reconnect

auto errors = client.on_error([&client](const reactor::ReactorError& error) {
  if (error.recoverable()) {
    std::this_thread::sleep_for(
        std::chrono::milliseconds(static_cast<long>(error.retry_after_ms().value_or(3000))));
    client.reconnect();
  }
});

Auto-reconnect

let errors = reactor.onError { error in
  guard error.recoverable else { return }
  Task {
    try await Task.sleep(for: .milliseconds(error.retryAfterMS ?? 3000))
    try await reactor.reconnect()
  }
}

Auto-reconnect

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

var errors = reactor.onError(error -> {
    if (error.isRecoverable()) {
        long delay = error.retryAfterMs() == null ? 3000L : error.retryAfterMs();
        CompletableFuture.runAsync(() -> {},
                CompletableFuture.delayedExecutor(delay, TimeUnit.MILLISECONDS))
            .thenCompose(ignored -> reactor.reconnect())
            .exceptionally(failure -> {
                System.err.println("Reconnect failed: " + failure.getMessage());
                return null;
            });
    }
});

The delay runs asynchronously so it does not block event delivery. Keep the client open until the retry completes.

Multiple clients can connect to one session at the same time. Create a session on one client (or your backend), read its id (getSessionId() in JavaScript, reactor.session_id in Python, session_id() in C++, reactor.sessionID in Swift, reactor.sessionId() in Java), then adopt it from another client by passing the session id to connect(). The creator owns the session lifecycle; clients that adopt it leave it running when they disconnect.

Adopt a session

// sessionId from your backend or another client
await reactor.connect(token, { sessionId });

Adopt a session

<ReactorProvider
  modelName="your-model-name"
  jwtToken={token}
  connectOptions={{ sessionId, autoConnect: true }}
>
  <ReactorView className="w-full aspect-video" />
</ReactorProvider>

Adopt a session

# session_id from your backend or another client's reactor.session_id
await reactor.connect(session_id=session_id)

Adopt a session

// session_id from your backend or another client's client.session_id()
reactor::ConnectOptions options;
options.session_id = session_id;
client.connect(options).get();

Adopt a session

// sessionID from your backend or another client's reactor.sessionID
try await reactor.connect(sessionID: sessionID)

Adopt a session

// sessionId comes from your backend or another client's reactor.sessionId().
reactor.connect(sessionId, null).join();

Passing null for the connection ID registers a new connection to the existing session.

See Sessions › Multiple connections per session for the full lifecycle and connection-id details.

Test a local model with Python

To verify a model’s video and commands without a browser, follow Local testing. That guide includes a complete brightness model and the Python client script that tests it.

Full API reference

Typed model SDKs

HeliosModel, LingbotModel, and their React layers over the base SDK.

JavaScript: Reactor class

The base class for connecting to any model and sending raw commands.

React components & hooks

ReactorProvider, ReactorView, WebcamStream, useReactor, and more.

Python: Reactor class

The base Python class, decorators, and types for server-side use.

Python: Track

The object form of a named media track — publish, push frames, receive, pause/resume.

C++: Reactor class

The base C++ class — connecting, commands, uploads, recordings, events.

C++: Track

The object form of a named media track — publish, push frames, receive, pause/resume.

Swift: Reactor class

The base Swift class — connecting, commands, uploads, recordings, events.

Swift: Track

The object form of a named media track — publish, push frames, receive, pause/resume.

Java: Reactor class

The base Java class — connecting, commands, uploads, recordings, and events.

Java: Track

Publish media, push frames, receive output, and pause or resume a named track.

Get Started

Concepts

SDK Reference

Resources

Two layers: base SDK and typed SDKs

Connecting

Receiving model output

Sending commands

File uploads

Receiving messages

Sending video input

Error handling

Reconnection

Test a local model with Python

Full API reference

Typed model SDKs

JavaScript: Reactor class

React components & hooks

Python: Reactor class

Python: Track

C++: Reactor class

C++: Track

Swift: Reactor class

Swift: Track

Java: Reactor class

Java: Track

​Two layers: base SDK and typed SDKs

​Connecting

​Receiving model output

​Sending commands

​File uploads

​Receiving messages

​Sending video input

​Error handling

​Reconnection

​Sharing a session

​Test a local model with Python

​Full API reference

Typed model SDKs

JavaScript: Reactor class

React components & hooks

Python: Reactor class

Python: Track

C++: Reactor class

C++: Track

Swift: Reactor class

Swift: Track

Java: Reactor class

Java: Track

Two layers: base SDK and typed SDKs

Connecting

Receiving model output

Sending commands

File uploads

Receiving messages

Sending video input

Error handling

Reconnection

Sharing a session

Test a local model with Python

Full API reference