@decartai/sdk 0.0.45 → 0.0.47

package/dist/index.d.ts

@@ -6,6 +6,7 @@ import { QueueClient } from "./queue/client.js";
 import { DecartSDKError, ERROR_CODES } from "./utils/errors.js";
 import { ConnectionState } from "./realtime/types.js";
 import { SetInput } from "./realtime/methods.js";
+import { RealTimeSubscribeClient, SubscribeEvents, SubscribeOptions } from "./realtime/subscribe-client.js";
 import { AvatarOptions, Events, RealTimeClient, RealTimeClientConnectOptions, RealTimeClientInitialState } from "./realtime/client.js";
 import { ModelState } from "./shared/types.js";
 import { CreateTokenResponse, TokensClient } from "./tokens/client.js";
@@ -46,6 +47,7 @@ type DecartClientOptions = {
 declare const createDecartClient: (options?: DecartClientOptions) => {
   realtime: {
     connect: (stream: MediaStream | null, options: RealTimeClientConnectOptions) => Promise<RealTimeClient>;
+    subscribe: (options: SubscribeOptions) => Promise<RealTimeSubscribeClient>;
   };
   /**
    * Client for synchronous image generation.
@@ -119,4 +121,4 @@ declare const createDecartClient: (options?: DecartClientOptions) => {
   tokens: TokensClient;
 };
 //#endregion
-export { type AvatarOptions, type ConnectionState, type CreateTokenResponse, DecartClientOptions, type DecartSDKError, ERROR_CODES, type FileInput, type ImageModelDefinition, type ImageModels, type JobStatus, type JobStatusResponse, type JobSubmitResponse, type Model, type ModelDefinition, type ModelState, 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 SetInput, type TokensClient, type VideoModelDefinition, type VideoModels, createDecartClient, isImageModel, isRealtimeModel, isVideoModel, models };
+export { type AvatarOptions, type ConnectionState, type CreateTokenResponse, DecartClientOptions, type DecartSDKError, ERROR_CODES, type FileInput, type ImageModelDefinition, type ImageModels, type JobStatus, type JobStatusResponse, type JobSubmitResponse, type Model, type ModelDefinition, type ModelState, 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 SetInput, type SubscribeEvents, type SubscribeOptions, type TokensClient, type VideoModelDefinition, type VideoModels, createDecartClient, isImageModel, isRealtimeModel, isVideoModel, models };

package/dist/realtime/client.d.ts

@@ -43,6 +43,9 @@ type RealTimeClientConnectOptions = z.infer<typeof realTimeClientConnectOptionsS
 type Events = {
   connectionChange: ConnectionState;
   error: DecartSDKError;
+  generationTick: {
+    seconds: number;
+  };
 };
 type RealTimeClient = {
   set: (input: SetInput) => Promise<void>;
@@ -56,7 +59,8 @@ type RealTimeClient = {
   disconnect: () => void;
   on: <K extends keyof Events>(event: K, listener: (data: Events[K]) => void) => void;
   off: <K extends keyof Events>(event: K, listener: (data: Events[K]) => void) => void;
-  sessionId: string;
+  sessionId: string | null;
+  subscribeToken: string | null;
   setImage: (image: Blob | File | string | null, options?: {
     prompt?: string;
     enhance?: boolean;

package/dist/realtime/client.js

@@ -2,11 +2,11 @@ import { createWebrtcError } from "../utils/errors.js";
 import { modelDefinitionSchema } from "../shared/model.js";
 import { modelStateSchema } from "../shared/types.js";
 import { AudioStreamManager } from "./audio-stream-manager.js";
+import { createEventBuffer } from "./event-buffer.js";
 import { realtimeMethods } from "./methods.js";
+import { decodeSubscribeToken, encodeSubscribeToken } from "./subscribe-client.js";
 import { WebRTCManager } from "./webrtc-manager.js";
 import { z } from "zod";
-import mitt from "mitt";
-import { v4 } from "uuid";
 
 //#region src/realtime/client.ts
 async function blobToBase64(blob) {
@@ -66,10 +66,8 @@ const realTimeClientConnectOptionsSchema = z.object({
 const createRealTimeClient = (opts) => {
 	const { baseUrl, apiKey, integration } = opts;
 	const connect = async (stream, options) => {
-		const eventEmitter = mitt();
 		const parsedOptions = realTimeClientConnectOptionsSchema.safeParse(options);
 		if (!parsedOptions.success) throw parsedOptions.error;
-		const sessionId = v4();
 		const isAvatarLive = options.model.name === "live_avatar";
 		const { onRemoteStream, initialState, avatar } = parsedOptions.data;
 		let audioStreamManager;
@@ -91,22 +89,7 @@ const createRealTimeClient = (opts) => {
 				enhance: initialState.prompt.enhance
 			} : void 0;
 			const url = `${baseUrl}${options.model.urlPath}`;
-			const eventBuffer = [];
-			let buffering = true;
-			const emitOrBuffer = (event, data) => {
-				if (buffering) eventBuffer.push({
-					event,
-					data
-				});
-				else eventEmitter.emit(event, data);
-			};
-			const flushBufferedEvents = () => {
-				setTimeout(() => {
-					buffering = false;
-					for (const { event, data } of eventBuffer) eventEmitter.emit(event, data);
-					eventBuffer.length = 0;
-				}, 0);
-			};
+			const { emitter: eventEmitter, emitOrBuffer, flush, stop } = createEventBuffer();
 			webrtcManager = new WebRTCManager({
 				webrtcUrl: `${url}?api_key=${encodeURIComponent(apiKey)}&model=${encodeURIComponent(options.model.name)}`,
 				integration,
@@ -126,6 +109,17 @@ const createRealTimeClient = (opts) => {
 				initialPrompt
 			});
 			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;
+			};
+			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);
 			if (!isAvatarLive && initialState?.prompt) {
@@ -138,25 +132,29 @@ const createRealTimeClient = (opts) => {
 				isConnected: () => manager.isConnected(),
 				getConnectionState: () => manager.getConnectionState(),
 				disconnect: () => {
-					buffering = false;
-					eventBuffer.length = 0;
+					stop();
 					manager.cleanup();
 					audioStreamManager?.cleanup();
 				},
 				on: eventEmitter.on,
 				off: eventEmitter.off,
-				sessionId,
-				setImage: async (image, options$1) => {
-					if (image === null) return manager.setImage(null, options$1);
+				get sessionId() {
+					return sessionId;
+				},
+				get subscribeToken() {
+					return subscribeToken;
+				},
+				setImage: async (image, options) => {
+					if (image === null) return manager.setImage(null, options);
 					const base64 = await imageToBase64(image);
-					return manager.setImage(base64, options$1);
+					return manager.setImage(base64, options);
 				}
 			};
 			if (isAvatarLive && audioStreamManager) {
-				const manager$1 = audioStreamManager;
-				client.playAudio = (audio) => manager$1.playAudio(audio);
+				const manager = audioStreamManager;
+				client.playAudio = (audio) => manager.playAudio(audio);
 			}
-			flushBufferedEvents();
+			flush();
 			return client;
 		} catch (error) {
 			webrtcManager?.cleanup();
@@ -164,7 +162,47 @@ const createRealTimeClient = (opts) => {
 			throw error;
 		}
 	};
-	return { connect };
+	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;
+		try {
+			webrtcManager = new WebRTCManager({
+				webrtcUrl: subscribeUrl,
+				integration,
+				onRemoteStream: options.onRemoteStream,
+				onConnectionStateChange: (state) => {
+					emitOrBuffer("connectionChange", state);
+				},
+				onError: (error) => {
+					console.error("WebRTC subscribe error:", error);
+					emitOrBuffer("error", createWebrtcError(error));
+				}
+			});
+			const manager = webrtcManager;
+			await manager.connect(null);
+			const client = {
+				isConnected: () => manager.isConnected(),
+				getConnectionState: () => manager.getConnectionState(),
+				disconnect: () => {
+					stop();
+					manager.cleanup();
+				},
+				on: eventEmitter.on,
+				off: eventEmitter.off
+			};
+			flush();
+			return client;
+		} catch (error) {
+			webrtcManager?.cleanup();
+			throw error;
+		}
+	};
+	return {
+		connect,
+		subscribe
+	};
 };
 
 //#endregion

package/dist/realtime/event-buffer.js

@@ -0,0 +1,35 @@
+import mitt from "mitt";
+
+//#region src/realtime/event-buffer.ts
+function createEventBuffer() {
+	const emitter = mitt();
+	const buffer = [];
+	let buffering = true;
+	const emitOrBuffer = (event, data) => {
+		if (buffering) buffer.push({
+			event,
+			data
+		});
+		else emitter.emit(event, data);
+	};
+	const flush = () => {
+		setTimeout(() => {
+			buffering = false;
+			for (const { event, data } of buffer) emitter.emit(event, data);
+			buffer.length = 0;
+		}, 0);
+	};
+	const stop = () => {
+		buffering = false;
+		buffer.length = 0;
+	};
+	return {
+		emitter,
+		emitOrBuffer,
+		flush,
+		stop
+	};
+}
+
+//#endregion
+export { createEventBuffer };

package/dist/realtime/subscribe-client.d.ts

@@ -0,0 +1,22 @@
+import { DecartSDKError } from "../utils/errors.js";
+import { ConnectionState } from "./types.js";
+
+//#region src/realtime/subscribe-client.d.ts
+
+type SubscribeEvents = {
+  connectionChange: ConnectionState;
+  error: DecartSDKError;
+};
+type RealTimeSubscribeClient = {
+  isConnected: () => boolean;
+  getConnectionState: () => ConnectionState;
+  disconnect: () => void;
+  on: <K extends keyof SubscribeEvents>(event: K, listener: (data: SubscribeEvents[K]) => void) => void;
+  off: <K extends keyof SubscribeEvents>(event: K, listener: (data: SubscribeEvents[K]) => void) => void;
+};
+type SubscribeOptions = {
+  token: string;
+  onRemoteStream: (stream: MediaStream) => void;
+};
+//#endregion
+export { RealTimeSubscribeClient, SubscribeEvents, SubscribeOptions };

package/dist/realtime/subscribe-client.js

@@ -0,0 +1,20 @@
+//#region src/realtime/subscribe-client.ts
+function encodeSubscribeToken(sessionId, serverIp, serverPort) {
+	return btoa(JSON.stringify({
+		sid: sessionId,
+		ip: serverIp,
+		port: serverPort
+	}));
+}
+function decodeSubscribeToken(token) {
+	try {
+		const payload = JSON.parse(atob(token));
+		if (!payload.sid || !payload.ip || !payload.port) throw new Error("Invalid subscribe token format");
+		return payload;
+	} catch {
+		throw new Error("Invalid subscribe token");
+	}
+}
+
+//#endregion
+export { decodeSubscribeToken, encodeSubscribeToken };

package/dist/realtime/webrtc-connection.js

@@ -98,6 +98,15 @@ var WebRTCConnection = class {
 				this.setState("generating");
 				return;
 			}
+			if (msg.type === "generation_tick") {
+				this.websocketMessagesEmitter.emit("generationTick", msg);
+				return;
+			}
+			if (msg.type === "generation_ended") return;
+			if (msg.type === "session_id") {
+				this.websocketMessagesEmitter.emit("sessionId", msg);
+				return;
+			}
 			if (!this.pc) return;
 			switch (msg.type) {
 				case "ready": {
@@ -225,7 +234,6 @@ var WebRTCConnection = class {
 		}
 	}
 	async setupNewPeerConnection(turnConfig) {
-		if (!this.localStream) throw new Error("No local stream found");
 		if (this.pc) {
 			this.pc.getSenders().forEach((sender) => {
 				if (sender.track && this.pc) this.pc.removeTrack(sender);
@@ -240,12 +248,23 @@ var WebRTCConnection = class {
 		});
 		this.pc = new RTCPeerConnection({ iceServers });
 		this.setState("connecting");
-		if (this.callbacks.isAvatarLive) this.pc.addTransceiver("video", { direction: "recvonly" });
-		this.localStream.getTracks().forEach((track) => {
-			if (this.pc && this.localStream) this.pc.addTrack(track, this.localStream);
-		});
+		if (this.localStream) {
+			if (this.callbacks.isAvatarLive) this.pc.addTransceiver("video", { direction: "recvonly" });
+			this.localStream.getTracks().forEach((track) => {
+				if (this.pc && this.localStream) this.pc.addTrack(track, this.localStream);
+			});
+		} else {
+			this.pc.addTransceiver("video", { direction: "recvonly" });
+			this.pc.addTransceiver("audio", { direction: "recvonly" });
+		}
+		let fallbackStream = null;
 		this.pc.ontrack = (e) => {
 			if (e.streams?.[0]) this.callbacks.onRemoteStream?.(e.streams[0]);
+			else {
+				if (!fallbackStream) fallbackStream = new MediaStream();
+				fallbackStream.addTrack(e.track);
+				this.callbacks.onRemoteStream?.(fallbackStream);
+			}
 		};
 		this.pc.onicecandidate = (e) => {
 			this.send({

package/dist/realtime/webrtc-manager.js

@@ -21,6 +21,7 @@ var WebRTCManager = class {
 	connection;
 	config;
 	localStream = null;
+	subscribeMode = false;
 	managerState = "disconnected";
 	hasConnected = false;
 	isReconnecting = false;
@@ -66,17 +67,17 @@ var WebRTCManager = class {
 		this.emitState(state);
 	}
 	async reconnect() {
-		if (this.isReconnecting || this.intentionalDisconnect || !this.localStream) return;
+		if (this.isReconnecting || this.intentionalDisconnect) return;
+		if (!this.subscribeMode && !this.localStream) return;
 		const reconnectGeneration = ++this.reconnectGeneration;
 		this.isReconnecting = true;
 		this.emitState("reconnecting");
 		try {
 			await pRetry(async () => {
 				if (this.intentionalDisconnect || reconnectGeneration !== this.reconnectGeneration) throw new AbortError("Reconnect cancelled");
-				const stream = this.localStream;
-				if (!stream) throw new AbortError("Reconnect cancelled: no local stream");
+				if (!this.subscribeMode && !this.localStream) throw new AbortError("Reconnect cancelled: no local stream");
 				this.connection.cleanup();
-				await this.connection.connect(this.config.webrtcUrl, stream, CONNECTION_TIMEOUT, this.config.integration);
+				await this.connection.connect(this.config.webrtcUrl, this.localStream, CONNECTION_TIMEOUT, this.config.integration);
 				if (this.intentionalDisconnect || reconnectGeneration !== this.reconnectGeneration) {
 					this.connection.cleanup();
 					throw new AbortError("Reconnect cancelled");
@@ -103,6 +104,7 @@ var WebRTCManager = class {
 	}
 	async connect(localStream) {
 		this.localStream = localStream;
+		this.subscribeMode = localStream === null;
 		this.intentionalDisconnect = false;
 		this.hasConnected = false;
 		this.isReconnecting = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decartai/sdk",
-  "version": "0.0.45",
+  "version": "0.0.47",
   "description": "Decart's JavaScript SDK",
   "type": "module",
   "license": "MIT",
@@ -43,7 +43,6 @@
   "dependencies": {
     "mitt": "^3.0.1",
     "p-retry": "^6.2.1",
-    "uuid": "^13.0.0",
     "zod": "^4.0.17"
   },
   "scripts": {