Odyssey Class

constructor(config: ClientConfig)

import { Odyssey } from '@odysseyml/odyssey';

const client = new Odyssey({ apiKey: 'ody_your_api_key_here' });

async connect(handlers?: OdysseyEventHandlers): Promise<MediaStream>

disconnect(): void

client.disconnect();

startStream(options?: StartStreamOptions): Promise<string>

const streamId = await client.startStream({ prompt: 'A cat', portrait: true });
console.log('Stream started:', streamId);

// Image-to-video example
const mediaStream = await client.connect();
const imageFile = fileInput.files[0];
const streamId = await client.startStream({
  prompt: 'A cat',
  portrait: false,
  image: imageFile
});

interact(options: InteractOptions): Promise<string>

const ackPrompt = await client.interact({ prompt: 'Pet the cat' });
console.log('Interaction acknowledged:', ackPrompt);

endStream(): Promise<void>

await client.endStream();

attachToVideo(videoElement: HTMLVideoElement | null): HTMLVideoElement | null

const videoEl = document.querySelector('video');
client.attachToVideo(videoEl);

getRecording(streamId: string): Promise<Recording>

const recording = await client.getRecording('abc-123-def');
console.log('Video URL:', recording.video_url);
console.log('Duration:', recording.duration_seconds, 'seconds');

listStreamRecordings(options?: ListStreamRecordingsOptions): Promise<StreamRecordingsListResponse>

// Get recent recordings
const { recordings, total } = await client.listStreamRecordings({ limit: 20 });

// Paginate
const page2 = await client.listStreamRecordings({ limit: 20, offset: 20 });

simulate(options: SimulateOptions): Promise<SimulationJob>

const job = await client.simulate({
  script: [
    { timestamp_ms: 0, start: { prompt: 'A cat sitting on a windowsill' } },
    { timestamp_ms: 3000, interact: { prompt: 'The cat stretches' } },
    { timestamp_ms: 6000, interact: { prompt: 'The cat yawns' } },
    { timestamp_ms: 9000, end: {} }
  ],
  portrait: true
});
console.log('Simulation started:', job.job_id);

getSimulateStatus(simulationId: string): Promise<SimulationJobDetail>

const status = await client.getSimulateStatus(job.job_id);
console.log('Status:', status.status);
if (status.status === 'completed') {
  for (const stream of status.streams) {
    console.log('Stream:', stream.stream_id);
  }
}

listSimulations(options?: ListSimulationsOptions): Promise<SimulationJobsList>

const { jobs, total } = await client.listSimulations({ limit: 10 });
for (const sim of jobs) {
  console.log(`${sim.job_id}: ${sim.status}`);
}

cancelSimulation(simulationId: string): Promise<{ job_id: string; status: string }>

const cancelled = await client.cancelSimulation(job.job_id);
console.log(`Simulation ${cancelled.job_id} cancelled (status: ${cancelled.status})`);

const client = new Odyssey({ apiKey });

await client.connect({
 onBroadcastReady: ({ webrtcUrl, spectatorToken, hlsUrl }) => {
   console.log("WebRTC:", webrtcUrl);
   console.log("Token:", spectatorToken);
 },
});

await client.startStream({
 prompt: "A glowing alien ruin",
 broadcast: true,
});

connectToStream(
 webrtcUrl: string,
 spectatorToken: string
): Promise<SpectatorConnection>

const spectator = await Odyssey.connectToStream(
 webrtcUrl,
 spectatorToken
);

videoElement.srcObject = spectator.stream;

spectator.onDisconnect(() => {
 console.log("Broadcast ended");
});

get isConnected(): boolean

get currentStatus(): ConnectionStatus

get currentSessionId(): string | null

get mediaStream(): MediaStream | null

get connectionState(): RTCPeerConnectionState | null

get iceConnectionState(): RTCIceConnectionState | null