@decartai/sdk 0.0.68 → 0.1.0

package/README.md

@@ -15,12 +15,15 @@ yarn add @decartai/sdk
 ## Documentation
 
 For complete documentation, guides, and examples, visit:
-**https://docs.platform.decart.ai/sdks/javascript**
+**[https://docs.platform.decart.ai/sdks/javascript](https://docs.platform.decart.ai/sdks/javascript)**
 
 ## Quick Start
 
 ### Real-time Video Transformation
 
+Realtime connections are LiveKit-backed in the SDK. Existing client usage stays the same: provide a
+camera `MediaStream`, choose a realtime model, and handle the transformed remote stream.
+
 ```typescript
 import { createDecartClient, models } from "@decartai/sdk";
 
@@ -79,16 +82,53 @@ Options:
 - `"auto"` — mirror when the input track reports `facingMode: "user"` (mobile front cameras).
 - `true` — always mirror (e.g. desktop webcams).
 
-#### Output resolution
+### Watch a Stream
 
-```ts
+A connected realtime session exposes an SDK `subscribeToken` once it reaches a
+connected state. Share that SDK token with viewers — `client.realtime.subscribe`
+uses it to request receive-only LiveKit credentials from Decart, then connects to
+the LiveKit room for the styled output stream. No viewer camera is required.
+
+**Producer** — capture the token from the active session:
+
+```typescript
 const realtimeClient = await client.realtime.connect(stream, {
   model,
-  resolution: "1080p", // default: "720p"
-  // ...
+  onRemoteStream: (transformedStream) => {
+    videoElement.srcObject = transformedStream;
+  },
+});
+
+realtimeClient.on("connectionChange", (state) => {
+  if ((state === "connected" || state === "generating") && realtimeClient.subscribeToken) {
+    const subscribeToken = realtimeClient.subscribeToken;
+    // Pass `subscribeToken` to the viewer snippet below.
+  }
 });
 ```
 
+**Viewer** — attach to the producer's stream with the token:
+
+```typescript
+import { createDecartClient, type RealTimeSubscribeClient } from "@decartai/sdk";
+
+const client = createDecartClient({ apiKey: "your-api-key-here" });
+
+const subscriber: RealTimeSubscribeClient = await client.realtime.subscribe({
+  token: subscribeToken,
+  onRemoteStream: (stream) => {
+    videoElement.srcObject = stream;
+  },
+});
+
+subscriber.on("connectionChange", (state) => {
+  console.log(`Viewer state: ${state}`);
+});
+
+// Disconnect when done
+subscriber.disconnect();
+```
+
 ### Async Processing (Queue API)
 
 For video generation jobs, use the queue API to submit jobs and poll for results:
@@ -161,12 +201,12 @@ pnpm install
 
 1. **Version bump**: Run `pnpm release` to bump the version (this uses `bumpp` to create a new version tag) and push it to GitHub
 2. **Automated publish**: The GitHub Actions workflow will:
-   - Build the project
-   - Publish to npm
-   - Create a GitHub release with changelog
+  - Build the project
+  - Publish to npm
+  - Create a GitHub release with changelog
 
 The package is published to npm as `@decartai/sdk`.
 
 ## License
 
-MIT
+MIT

package/dist/index.d.ts

@@ -5,12 +5,12 @@ import { ProcessClient } from "./process/client.js";
 import { JobStatus, JobStatusResponse, JobSubmitResponse, QueueJobResult, QueueSubmitAndPollOptions, QueueSubmitOptions } from "./queue/types.js";
 import { QueueClient } from "./queue/client.js";
 import { DecartSDKError, ERROR_CODES } from "./utils/errors.js";
-import { ConnectionState } from "./realtime/types.js";
-import { ConnectionPhase, DiagnosticEvent, DiagnosticEventName, DiagnosticEvents, IceCandidateEvent, IceStateEvent, PeerConnectionStateEvent, PhaseTimingEvent, ReconnectEvent, SelectedCandidatePairEvent, SignalingStateEvent, VideoStallEvent } from "./realtime/observability/diagnostics.js";
+import { ClientSessionConnectionBreakdownEvent, ClientSessionConnectionBreakdownPhase, DiagnosticEvent, DiagnosticEventName, DiagnosticEvents, ReconnectEvent, VideoStallEvent } from "./realtime/observability/diagnostics.js";
 import { WebRTCStats } from "./realtime/observability/webrtc-stats.js";
+import { ConnectionState, GenerationEndedMessage, QueuePosition, QueuePositionMessage } from "./realtime/types.js";
 import { SetInput } from "./realtime/methods.js";
-import { RealTimeSubscribeClient, SubscribeEvents, SubscribeOptions } from "./realtime/subscribe-client.js";
 import { Events, RealTimeClient, RealTimeClientConnectOptions, RealTimeClientInitialState } from "./realtime/client.js";
+import { RealTimeSubscribeClient, SubscribeEvents, SubscribeOptions } from "./realtime/subscribe-client.js";
 import { ModelState } from "./shared/types.js";
 import { CreateTokenOptions, CreateTokenResponse, TokensClient } from "./tokens/client.js";
 
@@ -42,6 +42,8 @@ type DecartClientOptions = {
  * @param options.realtimeBaseUrl - Override the default WebSocket base URL for realtime connections.
  * @param options.integration - Optional integration identifier.
  *
+ * Realtime media uses LiveKit only (inference must enable it in `TRANSPORTS_ENABLED`).
+ *
  * @example
  * ```ts
  * //  (direct API access)Option 1: Explicit API key
@@ -134,4 +136,4 @@ declare const createDecartClient: (options?: DecartClientOptions) => {
   tokens: TokensClient;
 };
 //#endregion
-export { type CanonicalModel, type ConnectionPhase, type ConnectionState, type CreateTokenOptions, type CreateTokenResponse, type CustomModelDefinition, DecartClientOptions, type DecartSDKError, type DiagnosticEvent, type DiagnosticEventName, type DiagnosticEvents, ERROR_CODES, type FileInput, type IceCandidateEvent, type IceStateEvent, type ImageModelDefinition, type ImageModels, type JobStatus, type JobStatusResponse, type JobSubmitResponse, type ListedModelDefinition, type LogLevel, type Logger, type Model, type ModelDefinition, type ModelKind, type ModelState, type PeerConnectionStateEvent, type PhaseTimingEvent, type ProcessClient, type ProcessOptions, type QueueClient, type QueueJobResult, type QueueSubmitAndPollOptions, type QueueSubmitOptions, type ReactNativeFile, type RealTimeClient, type RealTimeClientConnectOptions, type RealTimeClientInitialState, type Events as RealTimeEvents, type RealTimeModels, type RealTimeSubscribeClient, type ReconnectEvent, type SelectedCandidatePairEvent, type SetInput, type SignalingStateEvent, type SubscribeEvents, type SubscribeOptions, type TokensClient, type VideoModelDefinition, type VideoModels, type VideoStallEvent, type WebRTCStats, createConsoleLogger, createDecartClient, isCanonicalModel, isImageModel, isModel, isRealtimeModel, isVideoModel, listModels, modelAliases, models, noopLogger, resolveCanonicalModelAlias, resolveModelAlias };
+export { type CanonicalModel, type ClientSessionConnectionBreakdownEvent, type ClientSessionConnectionBreakdownPhase, type ConnectionState, type CreateTokenOptions, type CreateTokenResponse, type CustomModelDefinition, DecartClientOptions, type DecartSDKError, type DiagnosticEvent, type DiagnosticEventName, type DiagnosticEvents, ERROR_CODES, type FileInput, type GenerationEndedMessage, type ImageModelDefinition, type ImageModels, type JobStatus, type JobStatusResponse, type JobSubmitResponse, type ListedModelDefinition, type LogLevel, type Logger, type Model, type ModelDefinition, type ModelKind, type ModelState, type ProcessClient, type ProcessOptions, type QueueClient, type QueueJobResult, type QueuePosition, type QueuePositionMessage, type QueueSubmitAndPollOptions, type QueueSubmitOptions, type ReactNativeFile, type RealTimeClient, type RealTimeClientConnectOptions, type RealTimeClientInitialState, type Events as RealTimeEvents, type RealTimeModels, type RealTimeSubscribeClient, type ReconnectEvent, type SetInput, type SubscribeEvents, type SubscribeOptions, type TokensClient, type VideoModelDefinition, type VideoModels, type VideoStallEvent, type WebRTCStats, createConsoleLogger, createDecartClient, isCanonicalModel, isImageModel, isModel, isRealtimeModel, isVideoModel, listModels, modelAliases, models, noopLogger, resolveCanonicalModelAlias, resolveModelAlias };

package/dist/index.js

@@ -2,12 +2,12 @@ import { ERROR_CODES, createInvalidApiKeyError, createInvalidBaseUrlError } from
 import { createProcessClient } from "./process/client.js";
 import { createQueueClient } from "./queue/client.js";
 import { isCanonicalModel, isImageModel, isModel, isRealtimeModel, isVideoModel, listModels, modelAliases, models, resolveCanonicalModelAlias, resolveModelAlias } from "./shared/model.js";
+import { createConsoleLogger, noopLogger } from "./utils/logger.js";
 import { createRealTimeClient } from "./realtime/client.js";
+import { createRealTimeSubscribeClient } from "./realtime/subscribe-client.js";
 import { createTokensClient } from "./tokens/client.js";
 import { readEnv } from "./utils/env.js";
-import { createConsoleLogger, noopLogger } from "./utils/logger.js";
 import { z } from "zod";
-
 //#region src/index.ts
 const proxySchema = z.union([z.string().url(), z.string().startsWith("/")]);
 const decartClientOptionsSchema = z.object({
@@ -31,6 +31,8 @@ const decartClientOptionsSchema = z.object({
 * @param options.realtimeBaseUrl - Override the default WebSocket base URL for realtime connections.
 * @param options.integration - Optional integration identifier.
 *
+* Realtime media uses LiveKit only (inference must enable it in `TRANSPORTS_ENABLED`).
+*
 * @example
 * ```ts
 * //  (direct API access)Option 1: Explicit API key
@@ -59,33 +61,46 @@ const createDecartClient = (options = {}) => {
 	if (isProxyMode && "proxy" in parsedOptions.data && parsedOptions.data.proxy) baseUrl = parsedOptions.data.proxy;
 	else baseUrl = parsedOptions.data.baseUrl || "https://api.decart.ai";
 	const { integration } = parsedOptions.data;
-	const logger = "logger" in options && options.logger ? options.logger : noopLogger;
-	const telemetryEnabled = "telemetry" in options && options.telemetry === false ? false : true;
+	const logger = "logger" in options && options.logger ? options.logger : createConsoleLogger("info");
+	const telemetryEnabled = !("telemetry" in options && options.telemetry === false);
+	const wsBaseUrl = parsedOptions.data.realtimeBaseUrl || "wss://api3.decart.ai";
+	const realtimePublish = createRealTimeClient({
+		baseUrl: wsBaseUrl,
+		apiKey: apiKey || "",
+		integration,
+		logger,
+		telemetryEnabled
+	});
+	const realtimeSubscribe = createRealTimeSubscribeClient({
+		baseUrl: isProxyMode || parsedOptions.data.baseUrl !== void 0 ? baseUrl : wsBaseUrl.replace(/^wss?:\/\//i, "https://"),
+		apiKey: apiKey || "",
+		integration,
+		logger
+	});
+	const process = createProcessClient({
+		baseUrl,
+		apiKey: apiKey || "",
+		integration
+	});
+	const queue = createQueueClient({
+		baseUrl,
+		apiKey: apiKey || "",
+		integration
+	});
+	const tokens = createTokensClient({
+		baseUrl,
+		apiKey: apiKey || "",
+		integration
+	});
 	return {
-		realtime: createRealTimeClient({
-			baseUrl: parsedOptions.data.realtimeBaseUrl || "wss://api3.decart.ai",
-			apiKey: apiKey || "",
-			integration,
-			logger,
-			telemetryEnabled
-		}),
-		process: createProcessClient({
-			baseUrl,
-			apiKey: apiKey || "",
-			integration
-		}),
-		queue: createQueueClient({
-			baseUrl,
-			apiKey: apiKey || "",
-			integration
-		}),
-		tokens: createTokensClient({
-			baseUrl,
-			apiKey: apiKey || "",
-			integration
-		})
+		realtime: {
+			connect: realtimePublish.connect,
+			subscribe: realtimeSubscribe.subscribe
+		},
+		process,
+		queue,
+		tokens
 	};
 };
-
 //#endregion
-export { ERROR_CODES, createConsoleLogger, createDecartClient, isCanonicalModel, isImageModel, isModel, isRealtimeModel, isVideoModel, listModels, modelAliases, models, noopLogger, resolveCanonicalModelAlias, resolveModelAlias };
+export { ERROR_CODES, createConsoleLogger, createDecartClient, isCanonicalModel, isImageModel, isModel, isRealtimeModel, isVideoModel, listModels, modelAliases, models, noopLogger, resolveCanonicalModelAlias, resolveModelAlias };

package/dist/process/client.js

@@ -1,7 +1,6 @@
 import { createInvalidInputError } from "../utils/errors.js";
 import { fileInputToBlob } from "../shared/request.js";
 import { sendRequest } from "./request.js";
-
 //#region src/process/client.ts
 const createProcessClient = (opts) => {
 	const { apiKey, baseUrl, integration } = opts;
@@ -23,6 +22,5 @@ const createProcessClient = (opts) => {
 	};
 	return _process;
 };
-
 //#endregion
-export { createProcessClient };
+export { createProcessClient };

package/dist/process/request.js

@@ -1,6 +1,5 @@
 import { createSDKError } from "../utils/errors.js";
 import { buildAuthHeaders, buildFormData } from "../shared/request.js";
-
 //#region src/process/request.ts
 async function sendRequest({ baseUrl, apiKey, model, inputs, signal, integration }) {
 	const formData = buildFormData(inputs);
@@ -21,6 +20,5 @@ async function sendRequest({ baseUrl, apiKey, model, inputs, signal, integration
 	}
 	return response.blob();
 }
-
 //#endregion
-export { sendRequest };
+export { sendRequest };

package/dist/queue/client.js

@@ -2,7 +2,6 @@ import { createInvalidInputError } from "../utils/errors.js";
 import { fileInputToBlob } from "../shared/request.js";
 import { pollUntilComplete } from "./polling.js";
 import { getJobContent, getJobStatus, submitJob } from "./request.js";
-
 //#region src/queue/client.ts
 const createQueueClient = (opts) => {
 	const { apiKey, baseUrl, integration } = opts;
@@ -68,6 +67,5 @@ const createQueueClient = (opts) => {
 		submitAndPoll
 	};
 };
-
 //#endregion
-export { createQueueClient };
+export { createQueueClient };

package/dist/queue/polling.js

@@ -35,6 +35,5 @@ async function pollUntilComplete({ checkStatus, getContent, onStatusChange, sign
 		await sleep(POLLING_DEFAULTS.interval);
 	}
 }
-
 //#endregion
-export { pollUntilComplete };
+export { pollUntilComplete };

package/dist/queue/request.js

@@ -1,6 +1,5 @@
 import { createQueueResultError, createQueueStatusError, createQueueSubmitError } from "../utils/errors.js";
 import { buildAuthHeaders, buildFormData } from "../shared/request.js";
-
 //#region src/queue/request.ts
 /**
 * Submit a job to the queue.
@@ -68,6 +67,5 @@ async function getJobContent({ baseUrl, apiKey, jobId, signal, integration }) {
 	}
 	return response.blob();
 }
-
 //#endregion
-export { getJobContent, getJobStatus, submitJob };
+export { getJobContent, getJobStatus, submitJob };

package/dist/realtime/client.d.ts

@@ -1,8 +1,8 @@
 import { CustomModelDefinition, ModelDefinition } from "../shared/model.js";
 import { DecartSDKError } from "../utils/errors.js";
-import { ConnectionState } from "./types.js";
 import { DiagnosticEvent } from "./observability/diagnostics.js";
 import { WebRTCStats } from "./observability/webrtc-stats.js";
+import { ConnectionState, GenerationEnded, GenerationTick, ImageSetOptions, QueuePosition } from "./types.js";
 import { SetInput } from "./methods.js";
 import { z } from "zod";
 
@@ -16,18 +16,27 @@ declare const realTimeClientInitialStateSchema: z.ZodObject<{
   image: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<Blob, Blob>, z.ZodCustom<File, File>, z.ZodString]>>;
 }, z.core.$strip>;
 type OnRemoteStreamFn = (stream: MediaStream) => void;
+type OnConnectionChangeFn = (state: ConnectionState) => void;
+type OnQueuePositionFn = (queuePosition: QueuePosition) => void;
 type RealTimeClientInitialState = z.infer<typeof realTimeClientInitialStateSchema>;
 declare const realTimeClientConnectOptionsSchema: z.ZodObject<{
   model: z.ZodObject<{
     name: z.ZodString;
     urlPath: z.ZodString;
     queueUrlPath: z.ZodOptional<z.ZodString>;
-    fps: z.ZodNumber;
+    fps: z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+      max: z.ZodOptional<z.ZodNumber>;
+      min: z.ZodOptional<z.ZodNumber>;
+      ideal: z.ZodOptional<z.ZodNumber>;
+      exact: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>]>;
     width: z.ZodNumber;
     height: z.ZodNumber;
     inputSchema: z.ZodOptional<z.ZodAny>;
   }, z.core.$strip>;
   onRemoteStream: z.ZodCustom<OnRemoteStreamFn, OnRemoteStreamFn>;
+  onConnectionChange: z.ZodOptional<z.ZodCustom<OnConnectionChangeFn, OnConnectionChangeFn>>;
+  onQueuePosition: z.ZodOptional<z.ZodCustom<OnQueuePositionFn, OnQueuePositionFn>>;
   initialState: z.ZodOptional<z.ZodObject<{
     prompt: z.ZodOptional<z.ZodObject<{
       text: z.ZodString;
@@ -35,7 +44,7 @@ declare const realTimeClientConnectOptionsSchema: z.ZodObject<{
     }, z.core.$strip>>;
     image: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<Blob, Blob>, z.ZodCustom<File, File>, z.ZodString]>>;
   }, z.core.$strip>>;
-  customizeOffer: z.ZodOptional<z.ZodCustom<z.core.$InferInnerFunctionTypeAsync<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>, z.core.$InferInnerFunctionTypeAsync<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>>;
+  queryParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
   mirror: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodBoolean]>>;
   resolution: z.ZodOptional<z.ZodEnum<{
     "720p": "720p";
@@ -47,10 +56,10 @@ type RealTimeClientConnectOptions = Omit<z.infer<typeof realTimeClientConnectOpt
 };
 type Events = {
   connectionChange: ConnectionState;
+  queuePosition: QueuePosition;
   error: DecartSDKError;
-  generationTick: {
-    seconds: number;
-  };
+  generationTick: GenerationTick;
+  generationEnded: GenerationEnded;
   diagnostic: DiagnosticEvent;
   stats: WebRTCStats;
 };
@@ -68,11 +77,8 @@ type RealTimeClient = {
   off: <K extends keyof Events>(event: K, listener: (data: Events[K]) => void) => void;
   sessionId: string | null;
   subscribeToken: string | null;
-  setImage: (image: Blob | File | string | null, options?: {
-    prompt?: string;
-    enhance?: boolean;
-    timeout?: number;
-  }) => Promise<void>;
+  getSubscribeToken: () => string | null;
+  setImage: (image: Blob | File | string | null, options?: ImageSetOptions) => Promise<void>;
 };
 //#endregion
 export { Events, RealTimeClient, RealTimeClientConnectOptions, RealTimeClientInitialState };

package/dist/realtime/client.js

@@ -1,94 +1,48 @@
 import { classifyWebrtcError } from "../utils/errors.js";
-import { modelDefinitionSchema } from "../shared/model.js";
+import { modelDefinitionSchema, resolveFpsNumber } from "../shared/model.js";
 import { modelStateSchema } from "../shared/types.js";
+import { createConsoleLogger } from "../utils/logger.js";
+import { imageToBase64 } from "../utils/media.js";
+import { isDesktopSafari } from "../utils/platform.js";
 import { createEventBuffer } from "./event-buffer.js";
 import { realtimeMethods } from "./methods.js";
 import { createMirroredStream, shouldMirrorTrack } from "./mirror-stream.js";
 import { RealtimeObservability } from "./observability/realtime-observability.js";
-import { decodeSubscribeToken, encodeSubscribeToken } from "./subscribe-client.js";
-import { WebRTCManager } from "./webrtc-manager.js";
+import { StreamSession } from "./stream-session.js";
 import { z } from "zod";
-
 //#region src/realtime/client.ts
-async function blobToBase64(blob) {
-	return new Promise((resolve, reject) => {
-		const reader = new FileReader();
-		reader.onloadend = () => {
-			const result = reader.result;
-			if (typeof result !== "string") {
-				reject(/* @__PURE__ */ new Error("FileReader did not return a string"));
-				return;
-			}
-			const base64 = result.split(",")[1];
-			if (!base64) {
-				reject(/* @__PURE__ */ new Error("Invalid data URL format"));
-				return;
-			}
-			resolve(base64);
-		};
-		reader.onerror = reject;
-		reader.readAsDataURL(blob);
-	});
-}
-async function imageToBase64(image) {
-	if (typeof image === "string") {
-		let url = null;
-		try {
-			url = new URL(image);
-		} catch {}
-		if (url?.protocol === "data:") {
-			const [, base64] = image.split(",", 2);
-			if (!base64) throw new Error("Invalid data URL image");
-			return base64;
-		}
-		if (url?.protocol === "http:" || url?.protocol === "https:") {
-			const response = await fetch(image);
-			if (!response.ok) throw new Error(`Failed to fetch image: ${response.status} ${response.statusText}`);
-			return blobToBase64(await response.blob());
-		}
-		return image;
-	}
-	return blobToBase64(image);
-}
 const realTimeClientInitialStateSchema = modelStateSchema;
-const createAsyncFunctionSchema = (schema) => z.custom((fn) => schema.implementAsync(fn));
 const realTimeClientConnectOptionsSchema = z.object({
 	model: modelDefinitionSchema,
 	onRemoteStream: z.custom((val) => typeof val === "function", { message: "onRemoteStream must be a function" }),
+	onConnectionChange: z.custom((val) => typeof val === "function", { message: "onConnectionChange must be a function" }).optional(),
+	onQueuePosition: z.custom((val) => typeof val === "function", { message: "onQueuePosition must be a function" }).optional(),
 	initialState: realTimeClientInitialStateSchema.optional(),
-	customizeOffer: createAsyncFunctionSchema(z.function()).optional(),
+	queryParams: z.record(z.string(), z.string()).optional(),
 	mirror: z.union([z.literal("auto"), z.boolean()]).optional(),
 	resolution: z.enum(["720p", "1080p"]).optional()
 });
 const createRealTimeClient = (opts) => {
-	const { baseUrl, apiKey, integration, logger } = opts;
+	const { baseUrl, apiKey, integration } = opts;
+	const logger = opts.logger ?? createConsoleLogger("info");
 	const connect = async (stream, options) => {
 		const parsedOptions = realTimeClientConnectOptionsSchema.safeParse(options);
 		if (!parsedOptions.success) throw parsedOptions.error;
-		const { onRemoteStream, initialState, resolution } = parsedOptions.data;
+		const { onRemoteStream, onConnectionChange, onQueuePosition, initialState, resolution } = parsedOptions.data;
 		const mirror = parsedOptions.data.mirror ?? false;
 		let inputStream = stream ?? new MediaStream();
 		let mirroredStream;
 		if (mirror !== false) try {
 			const firstVideoTrack = inputStream.getVideoTracks?.()[0];
 			if (firstVideoTrack && (mirror === true || shouldMirrorTrack(firstVideoTrack))) {
-				mirroredStream = createMirroredStream(inputStream, { fps: options.model.fps });
+				mirroredStream = createMirroredStream(inputStream, { fps: resolveFpsNumber(options.model.fps) });
 				inputStream = mirroredStream.stream;
 			} else if (mirror === true && !firstVideoTrack) logger.warn("mirror: true requested but no video track was found on the input stream");
 		} catch (error) {
 			logger.warn("Failed to mirror input stream; falling back to un-mirrored input", { error: error instanceof Error ? error.message : String(error) });
 		}
-		let webrtcManager;
-		const { emitter: eventEmitter, emitOrBuffer, flush, stop } = createEventBuffer();
-		const observability = new RealtimeObservability({
-			telemetryEnabled: opts.telemetryEnabled,
-			apiKey,
-			model: options.model.name,
-			integration,
-			logger,
-			onDiagnostic: (event) => emitOrBuffer("diagnostic", event),
-			onStats: opts.telemetryEnabled ? (stats) => emitOrBuffer("stats", stats) : void 0
-		});
+		let session;
+		let observability;
 		try {
 			const initialImage = initialState?.image ? await imageToBase64(initialState.image) : void 0;
 			const initialPrompt = initialState?.prompt ? {
@@ -96,50 +50,65 @@ const createRealTimeClient = (opts) => {
 				enhance: initialState.prompt.enhance
 			} : void 0;
 			const url = `${baseUrl}${options.model.urlPath}`;
-			const resolutionQs = resolution ? `&resolution=${encodeURIComponent(resolution)}` : "";
-			webrtcManager = new WebRTCManager({
-				webrtcUrl: `${url}?api_key=${encodeURIComponent(apiKey)}&model=${encodeURIComponent(options.model.name)}${resolutionQs}`,
+			const { emitter: eventEmitter, emitOrBuffer, flush, stop } = createEventBuffer();
+			observability = new RealtimeObservability({
+				telemetryEnabled: opts.telemetryEnabled,
+				apiKey,
+				model: options.model.name,
 				integration,
 				logger,
+				onDiagnostic: (event) => emitOrBuffer("diagnostic", event),
+				onStats: (stats) => emitOrBuffer("stats", stats)
+			});
+			const safariCodec = isDesktopSafari() ? "vp8" : void 0;
+			session = new StreamSession({
+				url: `${url}?${new URLSearchParams({
+					...safariCodec ? { livekit_server_codec: safariCodec } : {},
+					...options.queryParams ?? {},
+					api_key: apiKey,
+					model: options.model.name,
+					...resolution ? { resolution } : {}
+				}).toString()}`,
+				integration,
 				observability,
-				onRemoteStream,
-				onConnectionStateChange: (state) => {
-					emitOrBuffer("connectionChange", state);
-				},
-				onError: (error) => {
-					logger.error("WebRTC error", { error: error.message });
-					emitOrBuffer("error", classifyWebrtcError(error));
-				},
-				customizeOffer: options.customizeOffer,
-				vp8MinBitrate: 300,
-				vp8StartBitrate: 600,
+				localStream: inputStream,
 				initialImage,
-				initialPrompt
+				initialPrompt,
+				logger,
+				videoCodec: safariCodec
 			});
-			const manager = webrtcManager;
 			let sessionId = null;
 			let subscribeToken = null;
-			const sessionIdListener = (msg) => {
-				subscribeToken = encodeSubscribeToken(msg.session_id, msg.server_ip, msg.server_port);
-				sessionId = msg.session_id;
-				observability.sessionStarted(msg.session_id);
-			};
-			manager.getWebsocketMessageEmitter().on("sessionId", sessionIdListener);
-			const tickListener = (msg) => {
-				emitOrBuffer("generationTick", { seconds: msg.seconds });
-			};
-			manager.getWebsocketMessageEmitter().on("generationTick", tickListener);
-			await manager.connect(inputStream);
-			const methods = realtimeMethods(manager, imageToBase64);
+			session.on("remoteStream", onRemoteStream);
+			session.on("connectionChange", (state) => {
+				emitOrBuffer("connectionChange", state);
+				onConnectionChange?.(state);
+			});
+			session.on("queuePosition", (qp) => {
+				emitOrBuffer("queuePosition", qp);
+				onQueuePosition?.(qp);
+			});
+			session.on("sessionStarted", ({ sessionId: id, subscribeToken: token }) => {
+				sessionId = id;
+				subscribeToken = token;
+				observability?.sessionStarted(id);
+			});
+			session.on("generationTick", (e) => emitOrBuffer("generationTick", e));
+			session.on("generationEnded", (e) => emitOrBuffer("generationEnded", e));
+			session.on("error", (error) => {
+				logger.error("Realtime error", { error: error.message });
+				emitOrBuffer("error", classifyWebrtcError(error));
+			});
+			const activeSession = session;
+			await activeSession.connect();
 			const client = {
-				set: methods.set,
-				setPrompt: methods.setPrompt,
-				isConnected: () => manager.isConnected(),
-				getConnectionState: () => manager.getConnectionState(),
+				...realtimeMethods(activeSession, imageToBase64),
+				isConnected: () => activeSession.isConnected(),
+				getConnectionState: () => activeSession.getConnectionState(),
 				disconnect: () => {
-					observability.stop();
+					observability?.stop();
 					stop();
-					manager.cleanup();
+					activeSession.disconnect();
 					mirroredStream?.dispose();
 				},
 				on: eventEmitter.on,
@@ -150,76 +119,23 @@ const createRealTimeClient = (opts) => {
 				get subscribeToken() {
 					return subscribeToken;
 				},
-				setImage: async (image, options) => {
-					if (image === null) return manager.setImage(null, options);
+				getSubscribeToken: () => subscribeToken,
+				setImage: async (image, imgOptions) => {
+					if (image === null) return activeSession.setImage(null, imgOptions);
 					const base64 = await imageToBase64(image);
-					return manager.setImage(base64, options);
+					return activeSession.setImage(base64, imgOptions);
 				}
 			};
 			flush();
 			return client;
 		} catch (error) {
-			observability.stop();
-			webrtcManager?.cleanup();
+			observability?.stop();
+			session?.disconnect();
 			mirroredStream?.dispose();
 			throw error;
 		}
 	};
-	const subscribe = async (options) => {
-		const { sid, ip, port } = decodeSubscribeToken(options.token);
-		const subscribeUrl = `${baseUrl}/subscribe/${encodeURIComponent(sid)}?IP=${encodeURIComponent(ip)}&port=${encodeURIComponent(port)}&api_key=${encodeURIComponent(apiKey)}`;
-		const { emitter: eventEmitter, emitOrBuffer, flush, stop } = createEventBuffer();
-		let webrtcManager;
-		const observability = new RealtimeObservability({
-			telemetryEnabled: opts.telemetryEnabled,
-			apiKey,
-			integration,
-			logger,
-			onDiagnostic: (event) => emitOrBuffer("diagnostic", event),
-			onStats: opts.telemetryEnabled ? (stats) => emitOrBuffer("stats", stats) : void 0
-		});
-		observability.sessionStarted(sid);
-		try {
-			webrtcManager = new WebRTCManager({
-				webrtcUrl: subscribeUrl,
-				integration,
-				logger,
-				observability,
-				onRemoteStream: options.onRemoteStream,
-				onConnectionStateChange: (state) => {
-					emitOrBuffer("connectionChange", state);
-				},
-				onError: (error) => {
-					logger.error("WebRTC subscribe error", { error: error.message });
-					emitOrBuffer("error", classifyWebrtcError(error));
-				}
-			});
-			const manager = webrtcManager;
-			await manager.connect(null);
-			const client = {
-				isConnected: () => manager.isConnected(),
-				getConnectionState: () => manager.getConnectionState(),
-				disconnect: () => {
-					observability.stop();
-					stop();
-					manager.cleanup();
-				},
-				on: eventEmitter.on,
-				off: eventEmitter.off
-			};
-			flush();
-			return client;
-		} catch (error) {
-			observability.stop();
-			webrtcManager?.cleanup();
-			throw error;
-		}
-	};
-	return {
-		connect,
-		subscribe
-	};
+	return { connect };
 };
-
 //#endregion
-export { createRealTimeClient };
+export { createRealTimeClient };