@decartai/sdk 0.0.47 → 0.0.49

package/dist/realtime/webrtc-connection.js

@@ -4,15 +4,28 @@ import mitt from "mitt";
 //#region src/realtime/webrtc-connection.ts
 const ICE_SERVERS = [{ urls: "stun:stun.l.google.com:19302" }];
 const AVATAR_SETUP_TIMEOUT_MS = 3e4;
+const noopDiagnostic = () => {};
 var WebRTCConnection = class {
 	pc = null;
 	ws = null;
 	localStream = null;
 	connectionReject = null;
+	logger;
+	emitDiagnostic;
 	state = "disconnected";
 	websocketMessagesEmitter = mitt();
 	constructor(callbacks = {}) {
 		this.callbacks = callbacks;
+		this.logger = callbacks.logger ?? {
+			debug() {},
+			info() {},
+			warn() {},
+			error() {}
+		};
+		this.emitDiagnostic = callbacks.onDiagnostic ?? noopDiagnostic;
+	}
+	getPeerConnection() {
+		return this.pc;
 	}
 	async connect(url, localStream, timeout, integration) {
 		const deadline = Date.now() + timeout;
@@ -25,24 +38,37 @@ var WebRTCConnection = class {
 		});
 		connectAbort.catch(() => {});
 		this.connectionReject = (error) => rejectConnect(error);
+		const totalStart = performance.now();
 		try {
+			const wsStart = performance.now();
 			await Promise.race([new Promise((resolve, reject) => {
 				const timer = setTimeout(() => reject(/* @__PURE__ */ new Error("WebSocket timeout")), timeout);
 				this.ws = new WebSocket(wsUrl);
 				this.ws.onopen = () => {
 					clearTimeout(timer);
+					this.emitDiagnostic("phaseTiming", {
+						phase: "websocket",
+						durationMs: performance.now() - wsStart,
+						success: true
+					});
 					resolve();
 				};
 				this.ws.onmessage = (e) => {
 					try {
 						this.handleSignalingMessage(JSON.parse(e.data));
 					} catch (err) {
-						console.error("[WebRTC] Parse error:", err);
+						this.logger.error("Signaling message parse error", { error: String(err) });
 					}
 				};
 				this.ws.onerror = () => {
 					clearTimeout(timer);
 					const error = /* @__PURE__ */ new Error("WebSocket error");
+					this.emitDiagnostic("phaseTiming", {
+						phase: "websocket",
+						durationMs: performance.now() - wsStart,
+						success: false,
+						error: error.message
+					});
 					reject(error);
 					rejectConnect(error);
 				};
@@ -53,24 +79,65 @@ var WebRTCConnection = class {
 					rejectConnect(/* @__PURE__ */ new Error("WebSocket closed"));
 				};
 			}), connectAbort]);
-			if (this.callbacks.avatarImageBase64) await Promise.race([this.sendAvatarImage(this.callbacks.avatarImageBase64), connectAbort]);
-			if (this.callbacks.initialPrompt) await Promise.race([this.sendInitialPrompt(this.callbacks.initialPrompt), connectAbort]);
+			if (this.callbacks.initialImage) {
+				const imageStart = performance.now();
+				await Promise.race([this.setImageBase64(this.callbacks.initialImage, {
+					prompt: this.callbacks.initialPrompt?.text,
+					enhance: this.callbacks.initialPrompt?.enhance
+				}), connectAbort]);
+				this.emitDiagnostic("phaseTiming", {
+					phase: "avatar-image",
+					durationMs: performance.now() - imageStart,
+					success: true
+				});
+			} else if (this.callbacks.initialPrompt) {
+				const promptStart = performance.now();
+				await Promise.race([this.sendInitialPrompt(this.callbacks.initialPrompt), connectAbort]);
+				this.emitDiagnostic("phaseTiming", {
+					phase: "initial-prompt",
+					durationMs: performance.now() - promptStart,
+					success: true
+				});
+			}
+			const handshakeStart = performance.now();
 			await this.setupNewPeerConnection();
 			await Promise.race([new Promise((resolve, reject) => {
 				const checkConnection = setInterval(() => {
 					if (this.state === "connected" || this.state === "generating") {
 						clearInterval(checkConnection);
+						this.emitDiagnostic("phaseTiming", {
+							phase: "webrtc-handshake",
+							durationMs: performance.now() - handshakeStart,
+							success: true
+						});
 						resolve();
 					} else if (this.state === "disconnected") {
 						clearInterval(checkConnection);
+						this.emitDiagnostic("phaseTiming", {
+							phase: "webrtc-handshake",
+							durationMs: performance.now() - handshakeStart,
+							success: false,
+							error: "Connection lost during handshake"
+						});
 						reject(/* @__PURE__ */ new Error("Connection lost during WebRTC handshake"));
 					} else if (Date.now() >= deadline) {
 						clearInterval(checkConnection);
+						this.emitDiagnostic("phaseTiming", {
+							phase: "webrtc-handshake",
+							durationMs: performance.now() - handshakeStart,
+							success: false,
+							error: "Timeout"
+						});
 						reject(/* @__PURE__ */ new Error("Connection timeout"));
 					}
 				}, 100);
 				connectAbort.catch(() => clearInterval(checkConnection));
 			}), connectAbort]);
+			this.emitDiagnostic("phaseTiming", {
+				phase: "total",
+				durationMs: performance.now() - totalStart,
+				success: true
+			});
 		} finally {
 			this.connectionReject = null;
 		}
@@ -79,6 +146,7 @@ var WebRTCConnection = class {
 		try {
 			if (msg.type === "error") {
 				const error = new Error(msg.error);
+				error.source = "server";
 				this.callbacks.onError?.(error);
 				if (this.connectionReject) {
 					this.connectionReject(error);
@@ -141,7 +209,14 @@ var WebRTCConnection = class {
 					});
 					break;
 				case "ice-candidate":
-					if (msg.candidate) await this.pc.addIceCandidate(msg.candidate);
+					if (msg.candidate) {
+						await this.pc.addIceCandidate(msg.candidate);
+						this.emitDiagnostic("iceCandidate", {
+							source: "remote",
+							candidateType: msg.candidate.candidate?.match(/typ (\w+)/)?.[1] ?? "unknown",
+							protocol: msg.candidate.candidate?.match(/udp|tcp/i)?.[0]?.toLowerCase() ?? "unknown"
+						});
+					}
 					break;
 				case "ice-restart": {
 					const turnConfig = msg.turn_config;
@@ -150,7 +225,7 @@ var WebRTCConnection = class {
 				}
 			}
 		} catch (error) {
-			console.error("[WebRTC] Error:", error);
+			this.logger.error("Signaling handler error", { error: String(error) });
 			this.callbacks.onError?.(error);
 			this.connectionReject?.(error);
 		}
@@ -160,18 +235,9 @@ var WebRTCConnection = class {
 			this.ws.send(JSON.stringify(message));
 			return true;
 		}
-		console.warn("[WebRTC] Message dropped: WebSocket is not open");
+		this.logger.warn("Message dropped: WebSocket is not open");
 		return false;
 	}
-	async sendAvatarImage(imageBase64) {
-		return this.setImageBase64(imageBase64);
-	}
-	/**
-	* Send an image to the server (e.g., as a reference for inference).
-	* Can be called after connection is established.
-	* Pass null to clear the reference image or use a placeholder.
-	* Optionally include a prompt to send with the image.
-	*/
 	async setImageBase64(imageBase64, options) {
 		return new Promise((resolve, reject) => {
 			const timeoutId = setTimeout(() => {
@@ -249,7 +315,7 @@ var WebRTCConnection = class {
 		this.pc = new RTCPeerConnection({ iceServers });
 		this.setState("connecting");
 		if (this.localStream) {
-			if (this.callbacks.isAvatarLive) this.pc.addTransceiver("video", { direction: "recvonly" });
+			if (this.callbacks.modelName === "live_avatar") this.pc.addTransceiver("video", { direction: "recvonly" });
 			this.localStream.getTracks().forEach((track) => {
 				if (this.pc && this.localStream) this.pc.addTrack(track, this.localStream);
 			});
@@ -271,22 +337,90 @@ var WebRTCConnection = class {
 				type: "ice-candidate",
 				candidate: e.candidate
 			});
+			if (e.candidate) this.emitDiagnostic("iceCandidate", {
+				source: "local",
+				candidateType: e.candidate.type ?? "unknown",
+				protocol: e.candidate.protocol ?? "unknown",
+				address: e.candidate.address ?? void 0,
+				port: e.candidate.port ?? void 0
+			});
 		};
+		let prevPcState = "new";
 		this.pc.onconnectionstatechange = () => {
 			if (!this.pc) return;
 			const s = this.pc.connectionState;
+			this.emitDiagnostic("peerConnectionStateChange", {
+				state: s,
+				previousState: prevPcState,
+				timestampMs: performance.now()
+			});
+			prevPcState = s;
+			if (s === "connected") this.emitSelectedCandidatePair();
 			const nextState = s === "connected" ? "connected" : ["connecting", "new"].includes(s) ? "connecting" : "disconnected";
 			if (this.state === "generating" && nextState !== "disconnected") return;
 			this.setState(nextState);
 		};
+		let prevIceState = "new";
 		this.pc.oniceconnectionstatechange = () => {
-			if (this.pc?.iceConnectionState === "failed") {
+			if (!this.pc) return;
+			const newIceState = this.pc.iceConnectionState;
+			this.emitDiagnostic("iceStateChange", {
+				state: newIceState,
+				previousState: prevIceState,
+				timestampMs: performance.now()
+			});
+			prevIceState = newIceState;
+			if (newIceState === "failed") {
 				this.setState("disconnected");
 				this.callbacks.onError?.(/* @__PURE__ */ new Error("ICE connection failed"));
 			}
 		};
+		let prevSignalingState = "stable";
+		this.pc.onsignalingstatechange = () => {
+			if (!this.pc) return;
+			const newState = this.pc.signalingState;
+			this.emitDiagnostic("signalingStateChange", {
+				state: newState,
+				previousState: prevSignalingState,
+				timestampMs: performance.now()
+			});
+			prevSignalingState = newState;
+		};
 		this.handleSignalingMessage({ type: "ready" });
 	}
+	async emitSelectedCandidatePair() {
+		if (!this.pc) return;
+		try {
+			const stats = await this.pc.getStats();
+			let found = false;
+			stats.forEach((report) => {
+				if (found) return;
+				if (report.type === "candidate-pair" && report.state === "succeeded") {
+					found = true;
+					let localCandidate;
+					let remoteCandidate;
+					stats.forEach((r) => {
+						if (r.id === report.localCandidateId) localCandidate = r;
+						if (r.id === report.remoteCandidateId) remoteCandidate = r;
+					});
+					if (localCandidate && remoteCandidate) this.emitDiagnostic("selectedCandidatePair", {
+						local: {
+							candidateType: String(localCandidate.candidateType ?? "unknown"),
+							protocol: String(localCandidate.protocol ?? "unknown"),
+							address: localCandidate.address,
+							port: localCandidate.port
+						},
+						remote: {
+							candidateType: String(remoteCandidate.candidateType ?? "unknown"),
+							protocol: String(remoteCandidate.protocol ?? "unknown"),
+							address: remoteCandidate.address,
+							port: remoteCandidate.port
+						}
+					});
+				}
+			});
+		} catch {}
+	}
 	cleanup() {
 		this.pc?.close();
 		this.pc = null;
@@ -298,17 +432,17 @@ var WebRTCConnection = class {
 	applyCodecPreference(preferredCodecName) {
 		if (!this.pc) return;
 		if (typeof RTCRtpSender === "undefined" || typeof RTCRtpSender.getCapabilities !== "function") {
-			console.warn("RTCRtpSender capabilities are not available in this environment.");
+			this.logger.debug("RTCRtpSender capabilities not available in this environment");
 			return;
 		}
 		const videoTransceiver = this.pc.getTransceivers().find((r) => r.sender.track?.kind === "video" || r.receiver.track?.kind === "video");
 		if (!videoTransceiver) {
-			console.error("Could not find video transceiver. Ensure track is added to peer connection.");
+			this.logger.warn("Video transceiver not found for codec preference");
 			return;
 		}
 		const capabilities = RTCRtpSender.getCapabilities("video");
 		if (!capabilities) {
-			console.error("Could not get video sender capabilities.");
+			this.logger.warn("Video sender capabilities unavailable");
 			return;
 		}
 		const preferredCodecs = [];
@@ -319,13 +453,13 @@ var WebRTCConnection = class {
 		});
 		const orderedCodecs = [...preferredCodecs, ...otherCodecs];
 		if (orderedCodecs.length === 0) {
-			console.warn("No video codecs found to set preferences for.");
+			this.logger.debug("No video codecs found for preference setting");
 			return;
 		}
 		try {
 			videoTransceiver.setCodecPreferences(orderedCodecs);
 		} catch {
-			console.warn("[WebRTC] setCodecPreferences not supported, skipping codec preference.");
+			this.logger.debug("setCodecPreferences not supported, skipping");
 		}
 	}
 	modifyVP8Bitrate(offer) {

package/dist/realtime/webrtc-manager.js

@@ -20,6 +20,7 @@ const RETRY_OPTIONS = {
 var WebRTCManager = class {
 	connection;
 	config;
+	logger;
 	localStream = null;
 	subscribeMode = false;
 	managerState = "disconnected";
@@ -29,6 +30,12 @@ var WebRTCManager = class {
 	reconnectGeneration = 0;
 	constructor(config) {
 		this.config = config;
+		this.logger = config.logger ?? {
+			debug() {},
+			info() {},
+			warn() {},
+			error() {}
+		};
 		this.connection = new WebRTCConnection({
 			onRemoteStream: config.onRemoteStream,
 			onStateChange: (state) => this.handleConnectionStateChange(state),
@@ -36,9 +43,11 @@ var WebRTCManager = class {
 			customizeOffer: config.customizeOffer,
 			vp8MinBitrate: config.vp8MinBitrate,
 			vp8StartBitrate: config.vp8StartBitrate,
-			isAvatarLive: config.isAvatarLive,
-			avatarImageBase64: config.avatarImageBase64,
-			initialPrompt: config.initialPrompt
+			modelName: config.modelName,
+			initialImage: config.initialImage,
+			initialPrompt: config.initialPrompt,
+			logger: this.logger,
+			onDiagnostic: config.onDiagnostic
 		});
 	}
 	emitState(state) {
@@ -72,8 +81,11 @@ var WebRTCManager = class {
 		const reconnectGeneration = ++this.reconnectGeneration;
 		this.isReconnecting = true;
 		this.emitState("reconnecting");
+		const reconnectStart = performance.now();
 		try {
+			let attemptCount = 0;
 			await pRetry(async () => {
+				attemptCount++;
 				if (this.intentionalDisconnect || reconnectGeneration !== this.reconnectGeneration) throw new AbortError("Reconnect cancelled");
 				if (!this.subscribeMode && !this.localStream) throw new AbortError("Reconnect cancelled: no local stream");
 				this.connection.cleanup();
@@ -86,7 +98,17 @@ var WebRTCManager = class {
 				...RETRY_OPTIONS,
 				onFailedAttempt: (error) => {
 					if (this.intentionalDisconnect || reconnectGeneration !== this.reconnectGeneration) return;
-					console.error(`[WebRTC] Reconnect attempt failed: ${error.message}`);
+					this.logger.warn("Reconnect attempt failed", {
+						error: error.message,
+						attempt: error.attemptNumber
+					});
+					this.config.onDiagnostic?.("reconnect", {
+						attempt: error.attemptNumber,
+						maxAttempts: RETRY_OPTIONS.retries + 1,
+						durationMs: performance.now() - reconnectStart,
+						success: false,
+						error: error.message
+					});
 					this.connection.cleanup();
 				},
 				shouldRetry: (error) => {
@@ -95,6 +117,12 @@ var WebRTCManager = class {
 					return !PERMANENT_ERRORS.some((err) => msg.includes(err));
 				}
 			});
+			this.config.onDiagnostic?.("reconnect", {
+				attempt: attemptCount,
+				maxAttempts: RETRY_OPTIONS.retries + 1,
+				durationMs: performance.now() - reconnectStart,
+				success: true
+			});
 		} catch (error) {
 			this.isReconnecting = false;
 			if (this.intentionalDisconnect || reconnectGeneration !== this.reconnectGeneration) return;
@@ -117,7 +145,10 @@ var WebRTCManager = class {
 		}, {
 			...RETRY_OPTIONS,
 			onFailedAttempt: (error) => {
-				console.error(`[WebRTC] Failed to connect: ${error.message}`);
+				this.logger.warn("Connection attempt failed", {
+					error: error.message,
+					attempt: error.attemptNumber
+				});
 				this.connection.cleanup();
 			},
 			shouldRetry: (error) => {
@@ -144,6 +175,9 @@ var WebRTCManager = class {
 	getConnectionState() {
 		return this.managerState;
 	}
+	getPeerConnection() {
+		return this.connection.getPeerConnection();
+	}
 	getWebsocketMessageEmitter() {
 		return this.connection.websocketMessagesEmitter;
 	}

package/dist/realtime/webrtc-stats.d.ts

@@ -0,0 +1,59 @@
+//#region src/realtime/webrtc-stats.d.ts
+type WebRTCStats = {
+  timestamp: number;
+  video: {
+    framesDecoded: number;
+    framesDropped: number;
+    framesPerSecond: number;
+    frameWidth: number;
+    frameHeight: number;
+    bytesReceived: number;
+    packetsReceived: number;
+    packetsLost: number;
+    jitter: number;
+    /** Estimated inbound bitrate in bits/sec, computed from bytesReceived delta. */
+    bitrate: number;
+    freezeCount: number;
+    totalFreezesDuration: number;
+    /** Delta: packets lost since previous sample. */
+    packetsLostDelta: number;
+    /** Delta: frames dropped since previous sample. */
+    framesDroppedDelta: number;
+    /** Delta: freeze count since previous sample. */
+    freezeCountDelta: number;
+    /** Delta: freeze duration (seconds) since previous sample. */
+    freezeDurationDelta: number;
+  } | null;
+  audio: {
+    bytesReceived: number;
+    packetsReceived: number;
+    packetsLost: number;
+    jitter: number;
+    /** Estimated inbound bitrate in bits/sec, computed from bytesReceived delta. */
+    bitrate: number;
+    /** Delta: packets lost since previous sample. */
+    packetsLostDelta: number;
+  } | null;
+  /** Outbound video track stats (from the local camera/screen share being sent). */
+  outboundVideo: {
+    /** Why the encoder is limiting quality: "none", "bandwidth", "cpu", or "other". */
+    qualityLimitationReason: string;
+    /** Cumulative time (seconds) spent in each quality limitation state. */
+    qualityLimitationDurations: Record<string, number>;
+    bytesSent: number;
+    packetsSent: number;
+    framesPerSecond: number;
+    frameWidth: number;
+    frameHeight: number;
+    /** Estimated outbound bitrate in bits/sec, computed from bytesSent delta. */
+    bitrate: number;
+  } | null;
+  connection: {
+    /** Current round-trip time in seconds, or null if unavailable. */
+    currentRoundTripTime: number | null;
+    /** Available outgoing bitrate estimate in bits/sec, or null if unavailable. */
+    availableOutgoingBitrate: number | null;
+  };
+};
+//#endregion
+export { WebRTCStats };

package/dist/realtime/webrtc-stats.js

@@ -0,0 +1,154 @@
+//#region src/realtime/webrtc-stats.ts
+const DEFAULT_INTERVAL_MS = 1e3;
+const MIN_INTERVAL_MS = 500;
+var WebRTCStatsCollector = class {
+	pc = null;
+	intervalId = null;
+	prevBytesVideo = 0;
+	prevBytesAudio = 0;
+	prevBytesSentVideo = 0;
+	prevTimestamp = 0;
+	prevPacketsLostVideo = 0;
+	prevFramesDropped = 0;
+	prevFreezeCount = 0;
+	prevFreezeDuration = 0;
+	prevPacketsLostAudio = 0;
+	onStats = null;
+	intervalMs;
+	constructor(options = {}) {
+		this.intervalMs = Math.max(options.intervalMs ?? DEFAULT_INTERVAL_MS, MIN_INTERVAL_MS);
+	}
+	/** Attach to a peer connection and start polling. */
+	start(pc, onStats) {
+		this.stop();
+		this.pc = pc;
+		this.onStats = onStats;
+		this.prevBytesVideo = 0;
+		this.prevBytesAudio = 0;
+		this.prevBytesSentVideo = 0;
+		this.prevTimestamp = 0;
+		this.prevPacketsLostVideo = 0;
+		this.prevFramesDropped = 0;
+		this.prevFreezeCount = 0;
+		this.prevFreezeDuration = 0;
+		this.prevPacketsLostAudio = 0;
+		this.intervalId = setInterval(() => this.collect(), this.intervalMs);
+	}
+	/** Stop polling and release resources. */
+	stop() {
+		if (this.intervalId !== null) {
+			clearInterval(this.intervalId);
+			this.intervalId = null;
+		}
+		this.pc = null;
+		this.onStats = null;
+	}
+	isRunning() {
+		return this.intervalId !== null;
+	}
+	async collect() {
+		if (!this.pc || !this.onStats) return;
+		try {
+			const rawStats = await this.pc.getStats();
+			const stats = this.parse(rawStats);
+			this.onStats(stats);
+		} catch {
+			this.stop();
+		}
+	}
+	parse(rawStats) {
+		const now = performance.now();
+		const elapsed = this.prevTimestamp > 0 ? (now - this.prevTimestamp) / 1e3 : 0;
+		let video = null;
+		let audio = null;
+		let outboundVideo = null;
+		const connection = {
+			currentRoundTripTime: null,
+			availableOutgoingBitrate: null
+		};
+		rawStats.forEach((report) => {
+			if (report.type === "inbound-rtp" && report.kind === "video") {
+				const bytesReceived = report.bytesReceived ?? 0;
+				const bitrate = elapsed > 0 ? (bytesReceived - this.prevBytesVideo) * 8 / elapsed : 0;
+				this.prevBytesVideo = bytesReceived;
+				const r = report;
+				const packetsLost = r.packetsLost ?? 0;
+				const framesDropped = r.framesDropped ?? 0;
+				const freezeCount = r.freezeCount ?? 0;
+				const freezeDuration = r.totalFreezesDuration ?? 0;
+				video = {
+					framesDecoded: r.framesDecoded ?? 0,
+					framesDropped,
+					framesPerSecond: r.framesPerSecond ?? 0,
+					frameWidth: r.frameWidth ?? 0,
+					frameHeight: r.frameHeight ?? 0,
+					bytesReceived,
+					packetsReceived: r.packetsReceived ?? 0,
+					packetsLost,
+					jitter: r.jitter ?? 0,
+					bitrate: Math.round(bitrate),
+					freezeCount,
+					totalFreezesDuration: freezeDuration,
+					packetsLostDelta: Math.max(0, packetsLost - this.prevPacketsLostVideo),
+					framesDroppedDelta: Math.max(0, framesDropped - this.prevFramesDropped),
+					freezeCountDelta: Math.max(0, freezeCount - this.prevFreezeCount),
+					freezeDurationDelta: Math.max(0, freezeDuration - this.prevFreezeDuration)
+				};
+				this.prevPacketsLostVideo = packetsLost;
+				this.prevFramesDropped = framesDropped;
+				this.prevFreezeCount = freezeCount;
+				this.prevFreezeDuration = freezeDuration;
+			}
+			if (report.type === "outbound-rtp" && report.kind === "video") {
+				const r = report;
+				const bytesSent = r.bytesSent ?? 0;
+				const outBitrate = elapsed > 0 ? (bytesSent - this.prevBytesSentVideo) * 8 / elapsed : 0;
+				this.prevBytesSentVideo = bytesSent;
+				outboundVideo = {
+					qualityLimitationReason: r.qualityLimitationReason ?? "none",
+					qualityLimitationDurations: r.qualityLimitationDurations ?? {},
+					bytesSent,
+					packetsSent: r.packetsSent ?? 0,
+					framesPerSecond: r.framesPerSecond ?? 0,
+					frameWidth: r.frameWidth ?? 0,
+					frameHeight: r.frameHeight ?? 0,
+					bitrate: Math.round(outBitrate)
+				};
+			}
+			if (report.type === "inbound-rtp" && report.kind === "audio") {
+				const bytesReceived = report.bytesReceived ?? 0;
+				const bitrate = elapsed > 0 ? (bytesReceived - this.prevBytesAudio) * 8 / elapsed : 0;
+				this.prevBytesAudio = bytesReceived;
+				const r = report;
+				const audioPacketsLost = r.packetsLost ?? 0;
+				audio = {
+					bytesReceived,
+					packetsReceived: r.packetsReceived ?? 0,
+					packetsLost: audioPacketsLost,
+					jitter: r.jitter ?? 0,
+					bitrate: Math.round(bitrate),
+					packetsLostDelta: Math.max(0, audioPacketsLost - this.prevPacketsLostAudio)
+				};
+				this.prevPacketsLostAudio = audioPacketsLost;
+			}
+			if (report.type === "candidate-pair") {
+				const r = report;
+				if (r.state === "succeeded") {
+					connection.currentRoundTripTime = r.currentRoundTripTime ?? null;
+					connection.availableOutgoingBitrate = r.availableOutgoingBitrate ?? null;
+				}
+			}
+		});
+		this.prevTimestamp = now;
+		return {
+			timestamp: Date.now(),
+			video,
+			audio,
+			outboundVideo,
+			connection
+		};
+	}
+};
+
+//#endregion
+export { WebRTCStatsCollector };

package/dist/shared/types.d.ts

@@ -6,6 +6,7 @@ declare const modelStateSchema: z.ZodObject<{
     text: z.ZodString;
     enhance: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
   }, z.core.$strip>>;
+  image: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<Blob, Blob>, z.ZodCustom<File, File>, z.ZodString]>>;
 }, z.core.$strip>;
 type ModelState = z.infer<typeof modelStateSchema>;
 //#endregion

package/dist/shared/types.js

@@ -1,10 +1,17 @@
 import { z } from "zod";
 
 //#region src/shared/types.ts
-const modelStateSchema = z.object({ prompt: z.object({
-	text: z.string().min(1),
-	enhance: z.boolean().optional().default(true)
-}).optional() });
+const modelStateSchema = z.object({
+	prompt: z.object({
+		text: z.string().min(1),
+		enhance: z.boolean().optional().default(true)
+	}).optional(),
+	image: z.union([
+		z.instanceof(Blob),
+		z.instanceof(File),
+		z.string()
+	]).optional()
+});
 
 //#endregion
 export { modelStateSchema };

package/dist/utils/errors.d.ts

@@ -8,7 +8,6 @@ type DecartSDKError = {
 declare const ERROR_CODES: {
   readonly INVALID_API_KEY: "INVALID_API_KEY";
   readonly INVALID_BASE_URL: "INVALID_BASE_URL";
-  readonly WEB_RTC_ERROR: "WEB_RTC_ERROR";
   readonly PROCESSING_ERROR: "PROCESSING_ERROR";
   readonly INVALID_INPUT: "INVALID_INPUT";
   readonly INVALID_OPTIONS: "INVALID_OPTIONS";
@@ -18,6 +17,11 @@ declare const ERROR_CODES: {
   readonly QUEUE_RESULT_ERROR: "QUEUE_RESULT_ERROR";
   readonly JOB_NOT_COMPLETED: "JOB_NOT_COMPLETED";
   readonly TOKEN_CREATE_ERROR: "TOKEN_CREATE_ERROR";
+  readonly WEBRTC_WEBSOCKET_ERROR: "WEBRTC_WEBSOCKET_ERROR";
+  readonly WEBRTC_ICE_ERROR: "WEBRTC_ICE_ERROR";
+  readonly WEBRTC_TIMEOUT_ERROR: "WEBRTC_TIMEOUT_ERROR";
+  readonly WEBRTC_SERVER_ERROR: "WEBRTC_SERVER_ERROR";
+  readonly WEBRTC_SIGNALING_ERROR: "WEBRTC_SIGNALING_ERROR";
 };
 //#endregion
 export { DecartSDKError, ERROR_CODES };