@decartai/sdk 0.0.67 → 0.1.0

package/dist/realtime/client.js

@@ -1,86 +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 { decodeSubscribeToken, encodeSubscribeToken } from "./subscribe-client.js";
-import { NullTelemetryReporter, TelemetryReporter } from "./telemetry-reporter.js";
-import { WebRTCManager } from "./webrtc-manager.js";
-import { WebRTCStatsCollector } from "./webrtc-stats.js";
+import { RealtimeObservability } from "./observability/realtime-observability.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(),
-	mirror: z.union([z.literal("auto"), z.boolean()]).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 } = 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;
-		let telemetryReporter = new NullTelemetryReporter();
-		let handleConnectionStateChange = null;
+		let session;
+		let observability;
 		try {
 			const initialImage = initialState?.image ? await imageToBase64(initialState.image) : void 0;
 			const initialPrompt = initialState?.prompt ? {
@@ -89,149 +51,64 @@ const createRealTimeClient = (opts) => {
 			} : void 0;
 			const url = `${baseUrl}${options.model.urlPath}`;
 			const { emitter: eventEmitter, emitOrBuffer, flush, stop } = createEventBuffer();
-			webrtcManager = new WebRTCManager({
-				webrtcUrl: `${url}?api_key=${encodeURIComponent(apiKey)}&model=${encodeURIComponent(options.model.name)}`,
+			observability = new RealtimeObservability({
+				telemetryEnabled: opts.telemetryEnabled,
+				apiKey,
+				model: options.model.name,
 				integration,
 				logger,
-				onDiagnostic: (name, data) => {
-					emitOrBuffer("diagnostic", {
-						name,
-						data
-					});
-					addTelemetryDiagnostic(name, data);
-				},
-				onRemoteStream,
-				onConnectionStateChange: (state) => {
-					emitOrBuffer("connectionChange", state);
-					handleConnectionStateChange?.(state);
-				},
-				onError: (error) => {
-					logger.error("WebRTC error", { error: error.message });
-					emitOrBuffer("error", classifyWebrtcError(error));
-				},
-				customizeOffer: options.customizeOffer,
-				vp8MinBitrate: 300,
-				vp8StartBitrate: 600,
+				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,
+				localStream: inputStream,
 				initialImage,
-				initialPrompt
+				initialPrompt,
+				logger,
+				videoCodec: safariCodec
 			});
-			const manager = webrtcManager;
 			let sessionId = null;
 			let subscribeToken = null;
-			const pendingTelemetryDiagnostics = [];
-			let telemetryReporterReady = false;
-			const addTelemetryDiagnostic = (name, data, timestamp = Date.now()) => {
-				if (!opts.telemetryEnabled) return;
-				if (!telemetryReporterReady) {
-					pendingTelemetryDiagnostics.push({
-						name,
-						data,
-						timestamp
-					});
-					return;
-				}
-				telemetryReporter.addDiagnostic({
-					name,
-					data,
-					timestamp
-				});
-			};
-			const sessionIdListener = (msg) => {
-				subscribeToken = encodeSubscribeToken(msg.session_id, msg.server_ip, msg.server_port);
-				sessionId = msg.session_id;
-				if (opts.telemetryEnabled) {
-					if (telemetryReporterReady) telemetryReporter.stop();
-					const reporter = new TelemetryReporter({
-						apiKey,
-						sessionId: msg.session_id,
-						model: options.model.name,
-						integration,
-						logger
-					});
-					reporter.start();
-					telemetryReporter = reporter;
-					telemetryReporterReady = true;
-					for (const diagnostic of pendingTelemetryDiagnostics) telemetryReporter.addDiagnostic(diagnostic);
-					pendingTelemetryDiagnostics.length = 0;
-				}
-			};
-			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);
-			let statsCollector = null;
-			let statsCollectorPeerConnection = null;
-			const STALL_FPS_THRESHOLD = .5;
-			let videoStalled = false;
-			let stallStartMs = 0;
-			const startStatsCollection = () => {
-				statsCollector?.stop();
-				videoStalled = false;
-				stallStartMs = 0;
-				statsCollector = new WebRTCStatsCollector();
-				const pc = manager.getPeerConnection();
-				statsCollectorPeerConnection = pc;
-				if (pc) statsCollector.start(pc, (stats) => {
-					emitOrBuffer("stats", stats);
-					telemetryReporter.addStats(stats);
-					const fps = stats.video?.framesPerSecond ?? 0;
-					if (!videoStalled && stats.video && fps < STALL_FPS_THRESHOLD) {
-						videoStalled = true;
-						stallStartMs = Date.now();
-						emitOrBuffer("diagnostic", {
-							name: "videoStall",
-							data: {
-								stalled: true,
-								durationMs: 0
-							}
-						});
-						addTelemetryDiagnostic("videoStall", {
-							stalled: true,
-							durationMs: 0
-						}, stallStartMs);
-					} else if (videoStalled && fps >= STALL_FPS_THRESHOLD) {
-						const durationMs = Date.now() - stallStartMs;
-						videoStalled = false;
-						emitOrBuffer("diagnostic", {
-							name: "videoStall",
-							data: {
-								stalled: false,
-								durationMs
-							}
-						});
-						addTelemetryDiagnostic("videoStall", {
-							stalled: false,
-							durationMs
-						});
-					}
-				});
-				return () => {
-					statsCollector?.stop();
-					statsCollector = null;
-					statsCollectorPeerConnection = null;
-				};
-			};
-			handleConnectionStateChange = (state) => {
-				if (!opts.telemetryEnabled) return;
-				if (state !== "connected" && state !== "generating") return;
-				const peerConnection = manager.getPeerConnection();
-				if (!peerConnection || peerConnection === statsCollectorPeerConnection) return;
-				startStatsCollection();
-			};
-			if (opts.telemetryEnabled) startStatsCollection();
+			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: () => {
-					statsCollector?.stop();
-					telemetryReporter.stop();
+					observability?.stop();
 					stop();
-					manager.cleanup();
+					activeSession.disconnect();
 					mirroredStream?.dispose();
 				},
 				on: eventEmitter.on,
@@ -242,70 +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) {
-			telemetryReporter.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;
-		try {
-			webrtcManager = new WebRTCManager({
-				webrtcUrl: subscribeUrl,
-				integration,
-				logger,
-				onDiagnostic: (name, data) => {
-					emitOrBuffer("diagnostic", {
-						name,
-						data
-					});
-				},
-				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: () => {
-					stop();
-					manager.cleanup();
-				},
-				on: eventEmitter.on,
-				off: eventEmitter.off
-			};
-			flush();
-			return client;
-		} catch (error) {
-			webrtcManager?.cleanup();
-			throw error;
-		}
-	};
-	return {
-		connect,
-		subscribe
-	};
+	return { connect };
 };
-
 //#endregion
-export { createRealTimeClient };
+export { createRealTimeClient };

package/dist/realtime/config-realtime.js

@@ -0,0 +1,49 @@
+//#region src/realtime/config-realtime.ts
+const REALTIME_CONFIG = {
+	signaling: {
+		connectTimeoutMs: 6e4,
+		handshakeTimeoutMs: 15e3,
+		requestTimeoutMs: 3e4
+	},
+	session: {
+		connectionTimeoutMs: 6e4 * 5,
+		retry: {
+			retries: 5,
+			factor: 2,
+			minTimeout: 1e3,
+			maxTimeout: 1e4
+		},
+		permanentErrorSubstrings: [
+			"permission denied",
+			"not allowed",
+			"invalid session",
+			"401",
+			"invalid api key",
+			"unauthorized"
+		]
+	},
+	methods: {
+		promptTimeoutMs: 15e3,
+		updateTimeoutMs: 3e4
+	},
+	livekit: {
+		inferenceServerIdentityPrefix: "inference-server-",
+		roomOptions: {
+			adaptiveStream: false,
+			dynacast: false
+		},
+		defaultVideoCodec: "h264",
+		defaultMaxVideoBitrateBps: 35e5,
+		defaultPublishFps: 30
+	},
+	observability: {
+		stallFpsThreshold: .5,
+		statsDefaultIntervalMs: 1e3,
+		statsMinIntervalMs: 500,
+		telemetryReportIntervalMs: 1e4,
+		telemetryUrl: "https://platform.decart.ai/api/v1/telemetry",
+		telemetryMaxItemsPerReport: 120
+	}
+};
+//#endregion
+export { REALTIME_CONFIG };

package/dist/realtime/event-buffer.js

@@ -1,5 +1,4 @@
 import mitt from "mitt";
-
 //#region src/realtime/event-buffer.ts
 function createEventBuffer() {
 	const emitter = mitt();
@@ -30,6 +29,5 @@ function createEventBuffer() {
 		stop
 	};
 }
-
 //#endregion
-export { createEventBuffer };
+export { createEventBuffer };

package/dist/realtime/initial-state-gate.js

@@ -0,0 +1,21 @@
+//#region src/realtime/initial-state-gate.ts
+var InitialStateGate = class {
+	attemptId = 0;
+	startAttempt(initialState) {
+		const attemptId = ++this.attemptId;
+		const shouldWait = hasCallerProvidedInitialState(initialState);
+		return { waitForReadiness: async (initialStateAck) => {
+			if (shouldWait) await initialStateAck;
+			return this.attemptId === attemptId;
+		} };
+	}
+	reset() {
+		this.attemptId++;
+	}
+};
+function hasCallerProvidedInitialState(state) {
+	if (!state) return false;
+	return state.image !== void 0 && state.image !== null || state.prompt !== void 0 && state.prompt !== null;
+}
+//#endregion
+export { InitialStateGate };

package/dist/realtime/media-channel.js

@@ -0,0 +1,82 @@
+import { createConsoleLogger } from "../utils/logger.js";
+import { REALTIME_CONFIG } from "./config-realtime.js";
+import mitt from "mitt";
+import { Room, RoomEvent, Track, TrackEvent } from "livekit-client";
+//#region src/realtime/media-channel.ts
+function getDefaultVideoPublishOptions(videoCodec) {
+	const videoEncoding = {
+		maxBitrate: REALTIME_CONFIG.livekit.defaultMaxVideoBitrateBps,
+		maxFramerate: REALTIME_CONFIG.livekit.defaultPublishFps
+	};
+	return {
+		source: Track.Source.Camera,
+		videoCodec: videoCodec ?? REALTIME_CONFIG.livekit.defaultVideoCodec,
+		simulcast: true,
+		videoEncoding
+	};
+}
+var MediaChannel = class {
+	room = null;
+	remoteStream = null;
+	events = mitt();
+	logger;
+	constructor(config) {
+		this.config = config;
+		this.logger = config.logger ?? createConsoleLogger("warn");
+	}
+	get localStream() {
+		return this.config.localStream;
+	}
+	on(event, handler) {
+		this.events.on(event, handler);
+	}
+	off(event, handler) {
+		this.events.off(event, handler);
+	}
+	async connect(opts) {
+		this.room ??= new Room(REALTIME_CONFIG.livekit.roomOptions);
+		const room = this.room;
+		room.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) {
+				this.remoteStream ??= new MediaStream();
+				if (!this.remoteStream.getTracks().includes(mediaStreamTrack)) this.remoteStream.addTrack(mediaStreamTrack);
+				this.events.emit("remoteStream", this.remoteStream);
+			}
+			track.on(TrackEvent.VideoPlaybackStarted, () => {
+				this.events.emit("firstFrame");
+			});
+		});
+		room.on(RoomEvent.Disconnected, (reason) => {
+			this.logger.warn("livekit: room disconnected", { reason });
+			this.events.emit("disconnected", { reason });
+		});
+		this.config.observability?.startPhase("webrtc-handshake");
+		await room.connect(opts.url, opts.token);
+		this.config.observability?.endPhase("webrtc-handshake", { success: true });
+		this.config.observability?.setLiveKitRoom(room);
+	}
+	async publishLocalTracks() {
+		if (!this.config.localStream) return;
+		this.config.observability?.startPhase("publish-local-track");
+		await this.publishTracks(this.config.localStream);
+		this.config.observability?.endPhase("publish-local-track", { success: true });
+	}
+	disconnect() {
+		const room = this.room;
+		this.room = null;
+		this.remoteStream = null;
+		this.config.observability?.setLiveKitRoom(null);
+		if (room) room.disconnect().catch(() => {});
+	}
+	async publishTracks(stream) {
+		if (!this.room) return;
+		for (const track of stream.getTracks()) if (track.kind === "video") await this.room.localParticipant.publishTrack(track, getDefaultVideoPublishOptions(this.config.videoCodec));
+		else await this.room.localParticipant.publishTrack(track);
+	}
+};
+//#endregion
+export { MediaChannel };

package/dist/realtime/methods.js

@@ -1,8 +1,6 @@
+import { REALTIME_CONFIG } from "./config-realtime.js";
 import { z } from "zod";
-
 //#region src/realtime/methods.ts
-const PROMPT_TIMEOUT_MS = 15 * 1e3;
-const UPDATE_TIMEOUT_MS = 30 * 1e3;
 const setInputSchema = z.object({
 	prompt: z.string().min(1).optional(),
 	enhance: z.boolean().optional().default(true),
@@ -17,61 +15,33 @@ const setPromptInputSchema = z.object({
 	prompt: z.string().min(1),
 	enhance: z.boolean().optional().default(true)
 });
-const realtimeMethods = (webrtcManager, imageToBase64) => {
-	const assertConnected = () => {
-		const state = webrtcManager.getConnectionState();
-		if (state !== "connected" && state !== "generating") throw new Error(`Cannot send message: connection is ${state}`);
-	};
+const realtimeMethods = (session, imageToBase64) => {
 	const set = async (input) => {
-		assertConnected();
 		const parsed = setInputSchema.safeParse(input);
 		if (!parsed.success) throw parsed.error;
 		const { prompt, enhance, image } = parsed.data;
-		let imageBase64 = null;
-		if (image !== void 0 && image !== null) imageBase64 = await imageToBase64(image);
-		await webrtcManager.setImage(imageBase64, {
+		const imageBase64 = image !== void 0 && image !== null ? await imageToBase64(image) : null;
+		await session.setImage(imageBase64, {
 			prompt,
 			enhance,
-			timeout: UPDATE_TIMEOUT_MS
+			timeout: REALTIME_CONFIG.methods.updateTimeoutMs
 		});
 	};
 	const setPrompt = async (prompt, { enhance } = {}) => {
-		assertConnected();
-		const parsedInput = setPromptInputSchema.safeParse({
+		const parsed = setPromptInputSchema.safeParse({
 			prompt,
 			enhance
 		});
-		if (!parsedInput.success) throw parsedInput.error;
-		const emitter = webrtcManager.getWebsocketMessageEmitter();
-		let promptAckListener;
-		let timeoutId;
-		try {
-			const ackPromise = new Promise((resolve, reject) => {
-				promptAckListener = (promptAckMessage) => {
-					if (promptAckMessage.prompt === parsedInput.data.prompt) if (promptAckMessage.success) resolve();
-					else reject(new Error(promptAckMessage.error ?? "Failed to send prompt"));
-				};
-				emitter.on("promptAck", promptAckListener);
-			});
-			if (!webrtcManager.sendMessage({
-				type: "prompt",
-				prompt: parsedInput.data.prompt,
-				enhance_prompt: parsedInput.data.enhance
-			})) throw new Error("WebSocket is not open");
-			const timeoutPromise = new Promise((_, reject) => {
-				timeoutId = setTimeout(() => reject(/* @__PURE__ */ new Error("Prompt timed out")), PROMPT_TIMEOUT_MS);
-			});
-			await Promise.race([ackPromise, timeoutPromise]);
-		} finally {
-			if (promptAckListener) emitter.off("promptAck", promptAckListener);
-			if (timeoutId) clearTimeout(timeoutId);
-		}
+		if (!parsed.success) throw parsed.error;
+		await session.sendPrompt(parsed.data.prompt, {
+			enhance: parsed.data.enhance,
+			timeout: REALTIME_CONFIG.methods.promptTimeoutMs
+		});
 	};
 	return {
 		set,
 		setPrompt
 	};
 };
-
 //#endregion
-export { realtimeMethods };
+export { realtimeMethods };

package/dist/realtime/mirror-stream.js

@@ -111,6 +111,5 @@ function createWithCanvas(sourceVideo, audioTracks, fps) {
 		}
 	};
 }
-
 //#endregion
-export { createMirroredStream, shouldMirrorTrack };
+export { createMirroredStream, shouldMirrorTrack };

package/dist/realtime/observability/diagnostics.d.ts

@@ -0,0 +1,39 @@
+//#region src/realtime/observability/diagnostics.d.ts
+type ClientSessionConnectionBreakdownPhase = {
+  phase: string;
+  durationMs: number;
+  success: boolean;
+  error?: string;
+};
+type ClientSessionConnectionBreakdownEvent = {
+  attempt: number;
+  success: boolean;
+  totalDurationMs: number;
+  initialImageSizeKb: number | null;
+  phases: ClientSessionConnectionBreakdownPhase[];
+  error?: string;
+};
+type ReconnectEvent = {
+  attempt: number;
+  maxAttempts: number;
+  durationMs: number;
+  success: boolean;
+  error?: string;
+};
+type VideoStallEvent = {
+  stalled: boolean;
+  durationMs: number;
+};
+type DiagnosticEvents = {
+  "client-session-connection-breakdown": ClientSessionConnectionBreakdownEvent;
+  reconnect: ReconnectEvent;
+  videoStall: VideoStallEvent;
+};
+type DiagnosticEventName = keyof DiagnosticEvents;
+type DiagnosticEventForName<K extends DiagnosticEventName> = {
+  name: K;
+  data: DiagnosticEvents[K];
+};
+type DiagnosticEvent = { [K in DiagnosticEventName]: DiagnosticEventForName<K> }[DiagnosticEventName];
+//#endregion
+export { ClientSessionConnectionBreakdownEvent, ClientSessionConnectionBreakdownPhase, DiagnosticEvent, DiagnosticEventName, DiagnosticEvents, ReconnectEvent, VideoStallEvent };