Lucy 2.6 Realtime

// Change to a new character
await realtimeClient.set({
  prompt: "Substitute the character in the video with the person in the reference image.",
  image: newCharacterImage,
  enhance: true,
});

// Set a new image only (clears any previous prompt)
await realtimeClient.set({ image: newCharacterImage });

// Set a new prompt only (clears any previous image)
await realtimeClient.set({ prompt: "Add dark sunglasses to the person's face." });

// Clear the reference image (fall back to text-only editing)
await realtimeClient.set({ image: null });

# Change to a new character
with open("new_character.jpg", "rb") as f:
    await realtime.set(
        prompt="Substitute the character in the video with the person in the reference image.",
        image=f,
        enhance=True,
    )

# Set a new image only (clears any previous prompt)
with open("another.jpg", "rb") as f:
    await realtime.set(image=f)

# Set a new prompt only (clears any previous image)
await realtime.set(prompt="Add dark sunglasses to the person's face.")

// Change to a new character
val newCharacterBase64 = Base64.encodeToString(newCharacterBytes, Base64.NO_WRAP)
client.realtime.setImage(
    imageBase64 = newCharacterBase64,
    prompt = "Substitute the character in the video with the person in the reference image.",
    enhance = true
)

// Set a new image only
client.realtime.setImage(imageBase64 = newCharacterBase64)

// Set a new prompt only (text-only editing)
client.realtime.setPrompt("Add dark sunglasses to the person's face.")

// Clear the reference image (fall back to text-only editing)
client.realtime.setImage(imageBase64 = null)

// No reference image needed for text-only edits
await realtimeClient.set({ prompt: "Add a pair of sunglasses to the person's face." });
await realtimeClient.set({ prompt: "Change the background to a sandy beach with clear blue water." });
await realtimeClient.set({ prompt: "Change the person's hair color to bright blonde." });

# No reference image needed for text-only edits
await realtime.set(prompt="Add a pair of sunglasses to the person's face.")
await realtime.set(prompt="Change the background to a sandy beach with clear blue water.")
await realtime.set(prompt="Change the person's hair color to bright blonde.")

// No reference image needed for text-only edits
client.realtime.setPrompt("Add a pair of sunglasses to the person's face.")
client.realtime.setPrompt("Change the background to a sandy beach with clear blue water.")
client.realtime.setPrompt("Change the person's hair color to bright blonde.")

import { createDecartClient, models, type DecartSDKError } from "@decartai/sdk";

async function setupLucy26() {
  const model = models.realtime("lucy-2.6");

  const stream = await navigator.mediaDevices.getUserMedia({
    video: {
      frameRate: model.fps,
      width: model.width,
      height: model.height,
    },
  });

  document.getElementById("input-video").srcObject = stream;

  const client = createDecartClient({
    apiKey: process.env.DECART_API_KEY,
  });

  const realtimeClient = await client.realtime.connect(stream, {
    model,
    onRemoteStream: (transformedStream) => {
      document.getElementById("output-video").srcObject = transformedStream;
    },
  });

  realtimeClient.on("connectionChange", (state) => {
    document.getElementById("status").textContent = state;
  });

  realtimeClient.on("generationTick", ({ seconds }) => {
    document.getElementById("usage").textContent = `${seconds}s`;
  });

  realtimeClient.on("error", (error: DecartSDKError) => {
    console.error("Lucy 2.6 error:", error.code, error.message);
  });

  document.getElementById("character-input").addEventListener("change", async (e) => {
    const file = (e.target as HTMLInputElement).files[0];
    if (file) {
      await realtimeClient.set({
        prompt: "Substitute the character in the video with the person in the reference image.",
        image: file,
        enhance: true,
      });
    }
  });

  window.addEventListener("beforeunload", () => {
    realtimeClient.disconnect();
    stream.getTracks().forEach((track) => track.stop());
  });

  return realtimeClient;
}

setupLucy26();

import asyncio
from decart import DecartClient, models

async def main():
    async with DecartClient(api_key="your-api-key-here") as client:
        model = models.realtime("lucy-2.6")

        realtime = await client.realtime.connect(
            stream=media_stream,
            model=model,
            on_remote_stream=lambda s: display(s),
        )

        @realtime.on("connection_change")
        def on_state(state):
            print(f"Connection: {state}")

        @realtime.on("generation_tick")
        def on_tick(seconds):
            print(f"Usage: {seconds}s")

        @realtime.on("error")
        def on_error(error):
            print(f"Lucy 2.6 error: {error.code} {error.message}")

        with open("character.jpg", "rb") as f:
            await realtime.set(
                prompt="Substitute the character in the video with the person in the reference image.",
                image=f,
                enhance=True,
            )

asyncio.run(main())

import ai.decart.sdk.*
import ai.decart.sdk.realtime.*
import org.webrtc.*

val model = RealtimeModels.LUCY_2_6
val client = DecartClient(context, DecartClientConfig(apiKey = "your-api-key"))
client.realtime.initialize(eglBase)

val videoSource = client.realtime.createVideoSource(false)!!
val videoTrack = client.realtime.createVideoTrack("camera", videoSource)!!
val enumerator = Camera2Enumerator(context)
val capturer = enumerator.createCapturer(
    enumerator.deviceNames.first { enumerator.isFrontFacing(it) }, null
)
capturer.initialize(
    SurfaceTextureHelper.create("CaptureThread", client.realtime.getEglBaseContext()),
    context, videoSource.capturerObserver
)
capturer.startCapture(model.width, model.height, model.fps)

client.realtime.connect(
    localVideoTrack = videoTrack,
    options = ConnectOptions(
        model = model,
        onRemoteVideoTrack = { track -> remoteRenderer.addSink(track) }
    )
)

lifecycleScope.launch {
    client.realtime.connectionState.collect { state -> statusText.text = state.name }
}
lifecycleScope.launch {
    client.realtime.generationTicks.collect { tick -> usageText.text = "${tick.seconds}s" }
}
lifecycleScope.launch {
    client.realtime.errors.collect { error ->
        Log.e("Lucy26", "Error: ${error.code} ${error.message}") }
}

fun onCharacterSelected(imageBytes: ByteArray) {
    val base64 = Base64.encodeToString(imageBytes, Base64.NO_WRAP)
    client.realtime.setImage(
        imageBase64 = base64,
        prompt = "Substitute the character in the video with the person in the reference image.",
        enhance = true
    )
}

capturer.stopCapture()
client.realtime.disconnect()
client.release()
eglBase.release()

// Backend: generate a short-lived token (expires in 60 s by default)
const token = await client.tokens.create();

// Frontend: let the SDK fetch a fresh token right before every connect and reconnect
const frontendClient = createDecartClient({
  apiKeyProvider: async () => {
    const res = await fetch("/api/realtime-token", { method: "POST" });
    const { apiKey } = await res.json();
    return apiKey;
  },
});

# Backend: generate a short-lived token
token = await client.tokens.create()

# Frontend: connect with the token
frontend_client = DecartClient(api_key=token.api_key)

// Fetch a short-lived token from your backend
val ephemeralKey = fetchTokenFromBackend()

// Connect with the token
val client = DecartClient(context, DecartClientConfig(apiKey = ephemeralKey))

const realtimeClient = await client.realtime.connect(stream, {
  model,
  speed: "fast", // fast mode
  onRemoteStream: (transformedStream) => {
    document.getElementById("output").srcObject = transformedStream;
  },
});

wss://api.decart.ai/v1/stream?api_key=YOUR_API_KEY&model=lucy-2.6&speed=fast