@decartai/sdk 0.0.68 → 0.1.0

package/dist/realtime/signaling-channel.js

@@ -0,0 +1,286 @@
+import { buildUserAgent } from "../utils/user-agent.js";
+import { createConsoleLogger } from "../utils/logger.js";
+import { REALTIME_CONFIG } from "./config-realtime.js";
+import mitt from "mitt";
+//#region src/realtime/signaling-channel.ts
+var SignalingChannel = class {
+	ws = null;
+	events = mitt();
+	pendingAcks = [];
+	pendingRoomInfo = null;
+	connected = false;
+	closing = false;
+	logger;
+	constructor(config) {
+		this.config = config;
+		this.logger = config.logger ?? createConsoleLogger("warn");
+	}
+	on(event, handler) {
+		this.events.on(event, handler);
+	}
+	off(event, handler) {
+		this.events.off(event, handler);
+	}
+	async openAndJoin(opts = {}) {
+		const connectTimeout = opts.connectTimeout ?? REALTIME_CONFIG.signaling.connectTimeoutMs;
+		const handshakeTimeout = opts.handshakeTimeout ?? REALTIME_CONFIG.signaling.handshakeTimeoutMs;
+		this.config.observability?.startPhase("websocket-open");
+		await this.openSocket(connectTimeout);
+		this.config.observability?.endPhase("websocket-open", { success: true });
+		this.config.observability?.startPhase("room-join");
+		const roomInfoWait = this.waitForRoomInfo(handshakeTimeout);
+		if (!this.writeMessage({ type: "livekit_join" })) {
+			roomInfoWait.cancel();
+			throw new Error("WebSocket is not open");
+		}
+		let roomInfo;
+		try {
+			roomInfo = await roomInfoWait.promise;
+		} catch (error) {
+			this.rejectAllPending(error instanceof Error ? error : new Error(String(error)));
+			throw error;
+		}
+		this.config.observability?.endPhase("room-join", { success: true });
+		this.connected = true;
+		const initialStateAck = this.sendInitialStateTracked(opts.initialState);
+		initialStateAck.catch(() => {});
+		return {
+			roomInfo,
+			initialStateAck
+		};
+	}
+	async sendInitialStateTracked(initialState) {
+		if (!initialState) return;
+		this.config.observability?.startPhase("initial-state-handshake");
+		await this.sendInitialState(initialState);
+		this.config.observability?.endPhase("initial-state-handshake", { success: true });
+	}
+	close() {
+		this.closing = true;
+		this.connected = false;
+		const ws = this.ws;
+		this.ws = null;
+		if (ws) try {
+			ws.close();
+		} catch {}
+		this.rejectPendingRoomInfo(/* @__PURE__ */ new Error("Control channel closed"));
+		this.rejectAllPending(/* @__PURE__ */ new Error("Control channel closed"));
+	}
+	async sendPrompt(text, opts = {}) {
+		const ack = await this.request({
+			message: {
+				type: "prompt",
+				prompt: text,
+				enhance_prompt: opts.enhance ?? true
+			},
+			matchAck: (msg) => msg.type === "prompt_ack" && msg.prompt === text,
+			timeoutMs: opts.timeout ?? REALTIME_CONFIG.signaling.requestTimeoutMs,
+			label: "Prompt send"
+		});
+		if (!ack.success) throw new Error(ack.error ?? "Failed to send prompt");
+	}
+	async setImage(image, opts = {}) {
+		const message = {
+			type: "set_image",
+			image_data: image
+		};
+		if (opts.prompt !== void 0) message.prompt = opts.prompt;
+		if (opts.enhance !== void 0) message.enhance_prompt = opts.enhance;
+		const ack = await this.request({
+			message,
+			matchAck: (msg) => msg.type === "set_image_ack",
+			timeoutMs: opts.timeout ?? REALTIME_CONFIG.signaling.requestTimeoutMs,
+			label: "Image send"
+		});
+		if (!ack.success) throw new Error(ack.error ?? "Failed to send image");
+	}
+	async openSocket(timeout) {
+		const userAgent = encodeURIComponent(buildUserAgent(this.config.integration));
+		const separator = this.config.url.includes("?") ? "&" : "?";
+		const wsUrl = `${this.config.url}${separator}user_agent=${userAgent}`;
+		this.closing = false;
+		await new Promise((resolve, reject) => {
+			const timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`WebSocket open timeout (${timeout}ms)`)), timeout);
+			const ws = new WebSocket(wsUrl);
+			this.ws = ws;
+			ws.onopen = () => {
+				clearTimeout(timer);
+				resolve();
+			};
+			ws.onclose = (e) => {
+				clearTimeout(timer);
+				const wasConnected = this.connected;
+				const pendingCount = this.pendingAcks.length;
+				this.connected = false;
+				this.ws = null;
+				this.logger.warn("signaling: websocket closed", {
+					code: e.code,
+					reason: e.reason,
+					wasConnected,
+					closing: this.closing,
+					pendingAcks: pendingCount
+				});
+				const error = /* @__PURE__ */ new Error(`WebSocket closed: ${e.code} ${e.reason}`);
+				this.rejectPendingRoomInfo(error);
+				this.rejectAllPending(error);
+				if (wasConnected || this.closing) this.events.emit("closed", {
+					code: e.code,
+					reason: e.reason
+				});
+				else reject(error);
+			};
+			ws.onerror = () => {};
+			ws.onmessage = (e) => {
+				try {
+					this.handleMessage(JSON.parse(e.data));
+				} catch {}
+			};
+		});
+	}
+	waitForRoomInfo(timeoutMs) {
+		let cleanup = () => {};
+		return {
+			promise: new Promise((resolve, reject) => {
+				let timer = setTimeout(() => {
+					cleanup();
+					this.logger.warn("signaling: livekit_room_info timeout", { timeoutMs });
+					reject(/* @__PURE__ */ new Error(`livekit_room_info timeout (${timeoutMs}ms)`));
+				}, timeoutMs);
+				const pendingRoomInfo = {
+					resolve: (info) => {
+						cleanup();
+						resolve(info);
+					},
+					reject: (err) => {
+						cleanup();
+						reject(err);
+					},
+					cancel: () => {
+						cleanup();
+					},
+					pauseTimeout: () => {
+						if (timer) {
+							clearTimeout(timer);
+							timer = null;
+						}
+					}
+				};
+				cleanup = () => {
+					if (timer) {
+						clearTimeout(timer);
+						timer = null;
+					}
+					if (this.pendingRoomInfo === pendingRoomInfo) this.pendingRoomInfo = null;
+				};
+				this.pendingRoomInfo = pendingRoomInfo;
+			}),
+			cancel: cleanup
+		};
+	}
+	async sendInitialState(initialState) {
+		if (!initialState) return;
+		if (initialState.image !== void 0) {
+			await this.setImage(initialState.image, {
+				prompt: initialState.prompt,
+				enhance: initialState.enhance
+			});
+			return;
+		}
+		if (initialState.prompt !== void 0 && initialState.prompt !== null) await this.sendPrompt(initialState.prompt, { enhance: initialState.enhance });
+	}
+	async request({ message, matchAck, timeoutMs, label }) {
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				cleanup();
+				this.logger.warn("signaling: ack timed out", {
+					label,
+					timeoutMs
+				});
+				reject(/* @__PURE__ */ new Error(`${label} timed out`));
+			}, timeoutMs);
+			const entry = {
+				matches: matchAck,
+				onMatch: (msg) => {
+					cleanup();
+					resolve(msg);
+				},
+				reject: (err) => {
+					cleanup();
+					reject(err);
+				}
+			};
+			const cleanup = () => {
+				clearTimeout(timer);
+				this.pendingAcks = this.pendingAcks.filter((e) => e !== entry);
+			};
+			this.pendingAcks.push(entry);
+			if (!this.writeMessage(message)) {
+				cleanup();
+				reject(/* @__PURE__ */ new Error("WebSocket is not open"));
+			}
+		});
+	}
+	writeMessage(message) {
+		if (this.ws?.readyState !== WebSocket.OPEN) return false;
+		this.ws.send(JSON.stringify(message));
+		return true;
+	}
+	handleMessage(msg) {
+		for (const ack of [...this.pendingAcks]) if (ack.matches(msg)) {
+			ack.onMatch(msg);
+			break;
+		}
+		switch (msg.type) {
+			case "livekit_room_info":
+				this.resolvePendingRoomInfo({
+					livekitUrl: msg.livekit_url,
+					token: msg.token,
+					roomName: msg.room_name,
+					sessionId: msg.session_id
+				});
+				break;
+			case "queue_position":
+				this.pendingRoomInfo?.pauseTimeout();
+				this.events.emit("queuePosition", {
+					position: msg.position,
+					queueSize: msg.queue_size
+				});
+				break;
+			case "generation_tick":
+				this.events.emit("generationTick", { seconds: msg.seconds });
+				break;
+			case "generation_ended":
+				this.events.emit("generationEnded", {
+					seconds: msg.seconds,
+					reason: msg.reason
+				});
+				break;
+			case "error": {
+				const error = new Error(msg.error);
+				error.source = "server";
+				this.logger.error("signaling: server error received", { error: msg.error });
+				this.events.emit("serverError", error);
+				this.rejectPendingRoomInfo(error);
+				this.rejectAllPending(error);
+				break;
+			}
+		}
+	}
+	resolvePendingRoomInfo(info) {
+		const pending = this.pendingRoomInfo;
+		if (!pending) return;
+		pending.resolve(info);
+	}
+	rejectPendingRoomInfo(error) {
+		const pending = this.pendingRoomInfo;
+		if (!pending) return;
+		pending.reject(error);
+	}
+	rejectAllPending(error) {
+		const pending = this.pendingAcks;
+		this.pendingAcks = [];
+		for (const entry of pending) entry.reject(error);
+	}
+};
+//#endregion
+export { SignalingChannel };

package/dist/realtime/stream-session.js

@@ -0,0 +1,252 @@
+import { createConsoleLogger } from "../utils/logger.js";
+import { REALTIME_CONFIG } from "./config-realtime.js";
+import { InitialStateGate } from "./initial-state-gate.js";
+import { MediaChannel } from "./media-channel.js";
+import { SignalingChannel } from "./signaling-channel.js";
+import mitt from "mitt";
+import pRetry, { AbortError } from "p-retry";
+//#region src/realtime/stream-session.ts
+function encodeSubscribeToken(roomName) {
+	return btoa(JSON.stringify({ room_name: roomName }));
+}
+function getInitialImageSizeKb(image) {
+	if (!image) return null;
+	const commaIdx = image.indexOf(",");
+	const base64 = commaIdx >= 0 && image.startsWith("data:") ? image.slice(commaIdx + 1) : image;
+	const padding = base64.endsWith("==") ? 2 : base64.endsWith("=") ? 1 : 0;
+	const bytes = Math.floor(base64.length * 3 / 4) - padding;
+	return Math.max(0, Math.round(bytes / 1024));
+}
+var StreamSession = class {
+	signaling;
+	media;
+	events = mitt();
+	state = "disconnected";
+	queue = null;
+	disposed = false;
+	currentAttempt = 0;
+	initialStateGate = new InitialStateGate();
+	logger;
+	constructor(config) {
+		this.config = config;
+		this.logger = config.logger ?? createConsoleLogger("warn");
+		this.createTransport();
+	}
+	on(event, handler) {
+		this.events.on(event, handler);
+	}
+	off(event, handler) {
+		this.events.off(event, handler);
+	}
+	getStatus() {
+		return {
+			connection: this.state,
+			queue: this.queue
+		};
+	}
+	getConnectionState() {
+		return this.state;
+	}
+	isConnected() {
+		return this.state === "connected" || this.state === "generating";
+	}
+	async connect() {
+		this.disposed = false;
+		const attempt = ++this.currentAttempt;
+		this.setState("connecting");
+		this.logger.info("realtime connect: starting", { attemptCycle: attempt });
+		try {
+			await pRetry(() => this.runOneConnect(attempt), this.retryOptionsFor(attempt));
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			this.logger.error("realtime connect: exhausted all retries", { error: message });
+			if (this.currentAttempt === attempt && !this.disposed) this.setState("disconnected");
+			throw error;
+		}
+	}
+	async sendPrompt(text, opts) {
+		this.assertConnected();
+		return this.signaling.sendPrompt(text, opts);
+	}
+	async setImage(image, opts) {
+		this.assertConnected();
+		return this.signaling.setImage(image, opts);
+	}
+	disconnect() {
+		this.disposed = true;
+		this.tearDown();
+		this.setState("disconnected");
+	}
+	assertConnected() {
+		if (!this.isConnected()) throw new Error(`Cannot send message: connection is ${this.state}`);
+	}
+	retryOptionsFor(attempt) {
+		return {
+			...REALTIME_CONFIG.session.retry,
+			onFailedAttempt: (_error) => {
+				this.tearDown();
+			},
+			shouldRetry: (error) => {
+				if (this.disposed || this.currentAttempt !== attempt) return false;
+				const msg = error.message.toLowerCase();
+				const permanent = REALTIME_CONFIG.session.permanentErrorSubstrings.some((err) => msg.includes(err));
+				if (permanent) this.logger.error("realtime connect: permanent error, not retrying", { error: error.message });
+				return !permanent;
+			}
+		};
+	}
+	async runOneConnect(attempt) {
+		if (this.disposed || this.currentAttempt !== attempt) throw new AbortError("Stale connect attempt");
+		try {
+			this.resetHandshakeState();
+			const initialState = this.getInitialState();
+			this.config.observability?.beginConnectionBreakdown(attempt, getInitialImageSizeKb(initialState?.image));
+			const gateAttempt = this.initialStateGate.startAttempt(initialState);
+			const { roomInfo, initialStateAck } = await this.signaling.openAndJoin({
+				connectTimeout: REALTIME_CONFIG.session.connectionTimeoutMs,
+				initialState
+			});
+			if (this.disposed || this.currentAttempt !== attempt) {
+				this.tearDown();
+				throw new AbortError("Stale connect attempt");
+			}
+			this.queue = null;
+			try {
+				await this.media.connect({
+					url: roomInfo.livekitUrl,
+					token: roomInfo.token
+				});
+				if (!await gateAttempt.waitForReadiness(initialStateAck)) throw new AbortError("Stale connect attempt");
+				await this.media.publishLocalTracks();
+			} catch (error) {
+				this.tearDown();
+				throw error;
+			}
+			if (this.disposed || this.currentAttempt !== attempt) {
+				this.tearDown();
+				throw new AbortError("Stale connect attempt");
+			}
+			this.config.observability?.finishConnectionBreakdown({ success: true });
+			this.setState("connected");
+			this.events.emit("sessionStarted", {
+				sessionId: roomInfo.sessionId,
+				subscribeToken: encodeSubscribeToken(roomInfo.roomName)
+			});
+		} catch (error) {
+			this.config.observability?.finishConnectionBreakdown({
+				success: false,
+				error: error instanceof Error ? error.message : String(error)
+			});
+			throw error;
+		}
+	}
+	getInitialState() {
+		if (this.config.initialImage !== void 0) return {
+			image: this.config.initialImage,
+			prompt: this.config.initialPrompt?.text,
+			enhance: this.config.initialPrompt?.enhance
+		};
+		if (this.config.initialPrompt) return {
+			prompt: this.config.initialPrompt.text,
+			enhance: this.config.initialPrompt.enhance
+		};
+		if (this.config.localStream) return {
+			image: null,
+			prompt: null
+		};
+	}
+	wireSignalingEvents() {
+		this.signaling.on("queuePosition", (qp) => {
+			this.queue = qp;
+			this.events.emit("queuePosition", qp);
+		});
+		this.signaling.on("generationTick", (e) => this.events.emit("generationTick", e));
+		this.signaling.on("generationEnded", (e) => this.events.emit("generationEnded", e));
+		this.signaling.on("serverError", (err) => this.events.emit("error", err));
+		this.signaling.on("closed", (info) => this.handleConnectionLoss({
+			source: "signaling",
+			...info
+		}));
+	}
+	wireMediaEvents() {
+		this.media.on("remoteStream", (stream) => this.events.emit("remoteStream", stream));
+		this.media.on("firstFrame", () => {
+			if (this.state === "connected") this.setState("generating");
+		});
+		this.media.on("disconnected", (info) => this.handleConnectionLoss({
+			source: "media",
+			reason: info.reason
+		}));
+	}
+	handleConnectionLoss(cause) {
+		if (this.disposed) return;
+		if (this.state !== "connected" && this.state !== "generating") {
+			this.logger.debug("connection loss ignored (not connected)", {
+				state: this.state,
+				...cause
+			});
+			return;
+		}
+		this.logger.warn("realtime connection lost; scheduling reconnect", {
+			state: this.state,
+			...cause
+		});
+		this.scheduleReconnect();
+	}
+	scheduleReconnect() {
+		const attempt = ++this.currentAttempt;
+		this.setState("reconnecting");
+		pRetry(async () => {
+			if (this.disposed || this.currentAttempt !== attempt) throw new AbortError("Reconnect cancelled");
+			this.tearDown();
+			this.createTransport();
+			await this.runOneConnect(attempt);
+		}, this.retryOptionsFor(attempt)).then(() => {
+			if (this.disposed || this.currentAttempt !== attempt) return;
+			this.logger.info("realtime reconnect: succeeded");
+		}).catch((error) => {
+			if (this.disposed || this.currentAttempt !== attempt) return;
+			const message = error instanceof Error ? error.message : String(error);
+			this.logger.error("realtime reconnect: failed permanently", { error: message });
+			this.tearDown();
+			this.setState("disconnected");
+			this.events.emit("error", error instanceof Error ? error : new Error(String(error)));
+		});
+	}
+	createTransport() {
+		this.signaling = new SignalingChannel({
+			url: this.config.url,
+			integration: this.config.integration,
+			logger: this.logger,
+			observability: this.config.observability
+		});
+		this.media = new MediaChannel({
+			observability: this.config.observability,
+			localStream: this.config.localStream,
+			logger: this.logger,
+			videoCodec: this.config.videoCodec
+		});
+		this.wireSignalingEvents();
+		this.wireMediaEvents();
+	}
+	tearDown() {
+		this.signaling.close();
+		this.media.disconnect();
+		this.initialStateGate.reset();
+		this.resetHandshakeState();
+	}
+	resetHandshakeState() {
+		this.queue = null;
+	}
+	setState(state) {
+		if (this.state === state) return;
+		this.logger.debug("realtime state change", {
+			from: this.state,
+			to: state
+		});
+		this.state = state;
+		this.events.emit("connectionChange", state);
+	}
+};
+//#endregion
+export { StreamSession };

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

@@ -1,7 +1,6 @@
 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 } from "./types.js";
 
 //#region src/realtime/subscribe-client.d.ts
 
@@ -9,7 +8,6 @@ type SubscribeEvents = {
   connectionChange: ConnectionState;
   error: DecartSDKError;
   diagnostic: DiagnosticEvent;
-  stats: WebRTCStats;
 };
 type RealTimeSubscribeClient = {
   isConnected: () => boolean;
@@ -21,6 +19,7 @@ type RealTimeSubscribeClient = {
 type SubscribeOptions = {
   token: string;
   onRemoteStream: (stream: MediaStream) => void;
+  onConnectionChange?: (state: ConnectionState) => void;
 };
 //#endregion
 export { RealTimeSubscribeClient, SubscribeEvents, SubscribeOptions };

package/dist/realtime/subscribe-client.js

@@ -1,20 +1,124 @@
+import { classifyWebrtcError } from "../utils/errors.js";
+import { createConsoleLogger } from "../utils/logger.js";
+import { createEventBuffer } from "./event-buffer.js";
+import { REALTIME_CONFIG } from "./config-realtime.js";
+import { RealtimeObservability } from "./observability/realtime-observability.js";
+import { ConnectionState, Room, RoomEvent, Track } from "livekit-client";
 //#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;
+		if (!payload.room_name || typeof payload.room_name !== "string") throw new Error("Invalid subscribe token format");
+		return { room_name: payload.room_name };
 	} catch {
 		throw new Error("Invalid subscribe token");
 	}
 }
-
+function mapLiveKitState(state) {
+	switch (state) {
+		case ConnectionState.Connecting: return "connecting";
+		case ConnectionState.Connected: return "connected";
+		case ConnectionState.Reconnecting:
+		case ConnectionState.SignalReconnecting: return "reconnecting";
+		case ConnectionState.Disconnected: return "disconnected";
+		default: return "disconnected";
+	}
+}
+async function fetchWatchStreamCredentials(opts) {
+	if (!/^https?:\/\//i.test(opts.baseUrl)) throw new Error(`watch-stream baseUrl must use http(s); got ${opts.baseUrl}`);
+	const url = `${opts.baseUrl}/watch-stream/${encodeURIComponent(opts.roomName)}`;
+	const res = await fetch(url, {
+		method: "POST",
+		headers: {
+			"x-api-key": opts.apiKey,
+			"content-type": "application/json"
+		}
+	});
+	if (!res.ok) {
+		const body = await res.text().catch(() => "");
+		throw new Error(`watch-stream request failed (${res.status}): ${body || res.statusText}`);
+	}
+	const json = await res.json();
+	if (!json.livekit_url || !json.token || !json.room_name) throw new Error("watch-stream response missing required fields");
+	return {
+		livekit_url: json.livekit_url,
+		token: json.token,
+		room_name: json.room_name
+	};
+}
+const createRealTimeSubscribeClient = (opts) => {
+	const { baseUrl, apiKey, integration } = opts;
+	const logger = opts.logger ?? createConsoleLogger("info");
+	const subscribe = async (options) => {
+		const { room_name: roomName } = decodeSubscribeToken(options.token);
+		const { emitter, emitOrBuffer, flush, stop } = createEventBuffer();
+		let observability;
+		let room;
+		let currentState = "connecting";
+		let remoteStream = null;
+		const setState = (state) => {
+			if (currentState === state) return;
+			currentState = state;
+			options.onConnectionChange?.(state);
+			emitOrBuffer("connectionChange", state);
+		};
+		try {
+			observability = new RealtimeObservability({
+				telemetryEnabled: false,
+				apiKey,
+				integration,
+				logger,
+				onDiagnostic: (event) => emitOrBuffer("diagnostic", event)
+			});
+			setState("connecting");
+			const creds = await fetchWatchStreamCredentials({
+				baseUrl,
+				apiKey,
+				roomName
+			});
+			room = new Room(REALTIME_CONFIG.livekit.roomOptions);
+			const activeRoom = room;
+			activeRoom.on(RoomEvent.TrackSubscribed, (track, _pub, participant) => {
+				if (!participant.identity.startsWith(REALTIME_CONFIG.livekit.inferenceServerIdentityPrefix)) return;
+				if (track.kind !== Track.Kind.Video && track.kind !== Track.Kind.Audio) return;
+				track.attach();
+				const mediaStreamTrack = track.mediaStreamTrack;
+				if (!mediaStreamTrack) return;
+				remoteStream ??= new MediaStream();
+				if (!remoteStream.getTracks().includes(mediaStreamTrack)) remoteStream.addTrack(mediaStreamTrack);
+				options.onRemoteStream(remoteStream);
+			});
+			activeRoom.on(RoomEvent.ConnectionStateChanged, (state) => {
+				setState(mapLiveKitState(state));
+			});
+			activeRoom.on(RoomEvent.Disconnected, () => {
+				setState("disconnected");
+			});
+			await activeRoom.connect(creds.livekit_url, creds.token);
+			observability.setLiveKitRoom(activeRoom);
+			setState("connected");
+			const client = {
+				isConnected: () => activeRoom.state === ConnectionState.Connected,
+				getConnectionState: () => mapLiveKitState(activeRoom.state),
+				disconnect: () => {
+					observability?.stop();
+					stop();
+					activeRoom.disconnect().catch(() => {});
+				},
+				on: emitter.on,
+				off: emitter.off
+			};
+			flush();
+			return client;
+		} catch (error) {
+			observability?.stop();
+			if (room) room.disconnect().catch(() => {});
+			const err = error instanceof Error ? error : new Error(String(error));
+			logger.error("Realtime subscribe error", { error: err.message });
+			throw classifyWebrtcError(err);
+		}
+	};
+	return { subscribe };
+};
 //#endregion
-export { decodeSubscribeToken, encodeSubscribeToken };
+export { createRealTimeSubscribeClient };