@decartai/sdk 0.0.68 → 0.1.0

package/dist/realtime/webrtc-connection.js

@@ -1,500 +0,0 @@
-import { buildUserAgent } from "../utils/user-agent.js";
-import mitt from "mitt";
-
-//#region src/realtime/webrtc-connection.ts
-const ICE_SERVERS = [{ urls: "stun:stun.l.google.com:19302" }];
-const SETUP_TIMEOUT_MS = 3e4;
-var WebRTCConnection = class {
-	pc = null;
-	ws = null;
-	localStream = null;
-	connectionReject = null;
-	logger;
-	observability;
-	state = "disconnected";
-	websocketMessagesEmitter = mitt();
-	constructor(callbacks) {
-		this.callbacks = callbacks;
-		this.logger = callbacks.logger ?? {
-			debug() {},
-			info() {},
-			warn() {},
-			error() {}
-		};
-		this.observability = callbacks.observability;
-	}
-	getPeerConnection() {
-		return this.pc;
-	}
-	async connect(url, localStream, timeout, integration) {
-		const deadline = Date.now() + timeout;
-		this.localStream = localStream;
-		const userAgent = encodeURIComponent(buildUserAgent(integration));
-		const wsUrl = `${url}${url.includes("?") ? "&" : "?"}user_agent=${userAgent}`;
-		let rejectConnect;
-		const connectAbort = new Promise((_, reject) => {
-			rejectConnect = reject;
-		});
-		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.observability.diagnostic("phaseTiming", {
-						phase: "websocket",
-						durationMs: performance.now() - wsStart,
-						success: true
-					});
-					resolve();
-				};
-				this.ws.onmessage = (e) => {
-					try {
-						this.handleSignalingMessage(JSON.parse(e.data));
-					} catch (err) {
-						this.logger.error("Signaling message parse error", { error: String(err) });
-					}
-				};
-				this.ws.onerror = () => {
-					clearTimeout(timer);
-					const error = /* @__PURE__ */ new Error("WebSocket error");
-					this.observability.diagnostic("phaseTiming", {
-						phase: "websocket",
-						durationMs: performance.now() - wsStart,
-						success: false,
-						error: error.message
-					});
-					reject(error);
-					rejectConnect(error);
-				};
-				this.ws.onclose = () => {
-					this.setState("disconnected");
-					clearTimeout(timer);
-					reject(/* @__PURE__ */ new Error("WebSocket closed before connection was established"));
-					rejectConnect(/* @__PURE__ */ new Error("WebSocket closed"));
-				};
-			}), 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.observability.diagnostic("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.observability.diagnostic("phaseTiming", {
-					phase: "initial-prompt",
-					durationMs: performance.now() - promptStart,
-					success: true
-				});
-			} else if (localStream) {
-				const nullStart = performance.now();
-				await Promise.race([this.setImageBase64(null, { prompt: null }), connectAbort]);
-				this.observability.diagnostic("phaseTiming", {
-					phase: "initial-prompt",
-					durationMs: performance.now() - nullStart,
-					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.observability.diagnostic("phaseTiming", {
-							phase: "webrtc-handshake",
-							durationMs: performance.now() - handshakeStart,
-							success: true
-						});
-						resolve();
-					} else if (this.state === "disconnected") {
-						clearInterval(checkConnection);
-						this.observability.diagnostic("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.observability.diagnostic("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.observability.diagnostic("phaseTiming", {
-				phase: "total",
-				durationMs: performance.now() - totalStart,
-				success: true
-			});
-		} finally {
-			this.connectionReject = null;
-		}
-	}
-	async handleSignalingMessage(msg) {
-		try {
-			if (msg.type === "error") {
-				const error = new Error(msg.error);
-				error.source = "server";
-				this.callbacks.onError?.(error);
-				if (this.connectionReject) {
-					this.connectionReject(error);
-					this.connectionReject = null;
-				}
-				return;
-			}
-			if (msg.type === "set_image_ack") {
-				this.websocketMessagesEmitter.emit("setImageAck", msg);
-				return;
-			}
-			if (msg.type === "prompt_ack") {
-				this.websocketMessagesEmitter.emit("promptAck", msg);
-				return;
-			}
-			if (msg.type === "generation_started") {
-				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": {
-					await this.applyCodecPreference("video/VP8");
-					const offer = await this.pc.createOffer();
-					this.modifyVP8Bitrate(offer);
-					await this.callbacks.customizeOffer?.(offer);
-					await this.pc.setLocalDescription(offer);
-					this.send({
-						type: "offer",
-						sdp: offer.sdp || ""
-					});
-					break;
-				}
-				case "offer": {
-					await this.pc.setRemoteDescription({
-						type: "offer",
-						sdp: msg.sdp
-					});
-					const answer = await this.pc.createAnswer();
-					await this.pc.setLocalDescription(answer);
-					this.send({
-						type: "answer",
-						sdp: answer.sdp || ""
-					});
-					break;
-				}
-				case "answer":
-					await this.pc.setRemoteDescription({
-						type: "answer",
-						sdp: msg.sdp
-					});
-					break;
-				case "ice-candidate":
-					if (msg.candidate) {
-						await this.pc.addIceCandidate(msg.candidate);
-						this.observability.diagnostic("iceCandidate", {
-							source: "remote",
-							candidateType: msg.candidate.candidate?.match(/typ (\w+)/)?.[1] ?? "unknown",
-							protocol: msg.candidate.candidate?.match(/udp|tcp/i)?.[0]?.toLowerCase() ?? "unknown"
-						});
-					}
-					break;
-			}
-		} catch (error) {
-			this.logger.error("Signaling handler error", { error: String(error) });
-			this.callbacks.onError?.(error);
-			this.connectionReject?.(error);
-		}
-	}
-	send(message) {
-		if (this.ws?.readyState === WebSocket.OPEN) {
-			this.ws.send(JSON.stringify(message));
-			return true;
-		}
-		this.logger.warn("Message dropped: WebSocket is not open");
-		return false;
-	}
-	async setImageBase64(imageBase64, options) {
-		return new Promise((resolve, reject) => {
-			const timeoutId = setTimeout(() => {
-				this.websocketMessagesEmitter.off("setImageAck", listener);
-				reject(/* @__PURE__ */ new Error("Image send timed out"));
-			}, options?.timeout ?? SETUP_TIMEOUT_MS);
-			const listener = (msg) => {
-				clearTimeout(timeoutId);
-				this.websocketMessagesEmitter.off("setImageAck", listener);
-				if (msg.success) resolve();
-				else reject(new Error(msg.error ?? "Failed to send image"));
-			};
-			this.websocketMessagesEmitter.on("setImageAck", listener);
-			const message = {
-				type: "set_image",
-				image_data: imageBase64
-			};
-			if (options?.prompt !== void 0) message.prompt = options.prompt;
-			if (options?.enhance !== void 0) message.enhance_prompt = options.enhance;
-			if (!this.send(message)) {
-				clearTimeout(timeoutId);
-				this.websocketMessagesEmitter.off("setImageAck", listener);
-				reject(/* @__PURE__ */ new Error("WebSocket is not open"));
-			}
-		});
-	}
-	/**
-	* Send the initial prompt to the server before WebRTC handshake.
-	*/
-	async sendInitialPrompt(prompt) {
-		return new Promise((resolve, reject) => {
-			const timeoutId = setTimeout(() => {
-				this.websocketMessagesEmitter.off("promptAck", listener);
-				reject(/* @__PURE__ */ new Error("Prompt send timed out"));
-			}, SETUP_TIMEOUT_MS);
-			const listener = (msg) => {
-				if (msg.prompt === prompt.text) {
-					clearTimeout(timeoutId);
-					this.websocketMessagesEmitter.off("promptAck", listener);
-					if (msg.success) resolve();
-					else reject(new Error(msg.error ?? "Failed to send prompt"));
-				}
-			};
-			this.websocketMessagesEmitter.on("promptAck", listener);
-			if (!this.send({
-				type: "prompt",
-				prompt: prompt.text,
-				enhance_prompt: prompt.enhance ?? true
-			})) {
-				clearTimeout(timeoutId);
-				this.websocketMessagesEmitter.off("promptAck", listener);
-				reject(/* @__PURE__ */ new Error("WebSocket is not open"));
-			}
-		});
-	}
-	setState(state) {
-		if (this.state !== state) {
-			this.state = state;
-			this.callbacks.onStateChange?.(state);
-		}
-	}
-	async setupNewPeerConnection() {
-		if (this.pc) {
-			this.pc.getSenders().forEach((sender) => {
-				if (sender.track && this.pc) this.pc.removeTrack(sender);
-			});
-			this.pc.close();
-		}
-		this.pc = new RTCPeerConnection({ iceServers: ICE_SERVERS });
-		this.setState("connecting");
-		if (this.localStream) 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({
-				type: "ice-candidate",
-				candidate: e.candidate
-			});
-			if (e.candidate) this.observability.diagnostic("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.observability.diagnostic("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) return;
-			const newIceState = this.pc.iceConnectionState;
-			this.observability.diagnostic("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.observability.diagnostic("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.observability.diagnostic("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;
-		this.ws?.close();
-		this.ws = null;
-		this.localStream = null;
-		this.setState("disconnected");
-	}
-	applyCodecPreference(preferredCodecName) {
-		if (!this.pc) return;
-		if (typeof RTCRtpSender === "undefined" || typeof RTCRtpSender.getCapabilities !== "function") {
-			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) {
-			this.logger.warn("Video transceiver not found for codec preference");
-			return;
-		}
-		const capabilities = RTCRtpSender.getCapabilities("video");
-		if (!capabilities) {
-			this.logger.warn("Video sender capabilities unavailable");
-			return;
-		}
-		const preferredCodecs = [];
-		const otherCodecs = [];
-		capabilities.codecs.forEach((codec) => {
-			if (codec.mimeType.toLowerCase() === preferredCodecName.toLowerCase()) preferredCodecs.push(codec);
-			else otherCodecs.push(codec);
-		});
-		const orderedCodecs = [...preferredCodecs, ...otherCodecs];
-		if (orderedCodecs.length === 0) {
-			this.logger.debug("No video codecs found for preference setting");
-			return;
-		}
-		try {
-			videoTransceiver.setCodecPreferences(orderedCodecs);
-		} catch {
-			this.logger.debug("setCodecPreferences not supported, skipping");
-		}
-	}
-	modifyVP8Bitrate(offer) {
-		if (!offer.sdp) return;
-		const minBitrateInKbps = this.callbacks.vp8MinBitrate;
-		const startBitrateInKbps = this.callbacks.vp8StartBitrate;
-		if (minBitrateInKbps === void 0 || startBitrateInKbps === void 0) return;
-		if (minBitrateInKbps === 0 && startBitrateInKbps === 0) return;
-		const bitrateParams = `x-google-min-bitrate=${minBitrateInKbps};x-google-start-bitrate=${startBitrateInKbps}`;
-		const sdpLines = offer.sdp.split("\r\n");
-		const modifiedLines = [];
-		for (let i = 0; i < sdpLines.length; i++) {
-			if (sdpLines[i].includes("VP8/90000")) {
-				const match = sdpLines[i].match(/a=rtpmap:(\d+) VP8/);
-				if (match) {
-					const payloadType = match[1];
-					let fmtpIndex = -1;
-					let insertAfterIndex = i;
-					for (let j = i + 1; j < sdpLines.length && sdpLines[j].startsWith("a="); j++) {
-						if (sdpLines[j].startsWith(`a=fmtp:${payloadType}`)) {
-							fmtpIndex = j;
-							break;
-						}
-						if (sdpLines[j].startsWith(`a=rtcp-fb:${payloadType}`)) insertAfterIndex = j;
-						if (sdpLines[j].startsWith("a=rtpmap:")) break;
-					}
-					if (fmtpIndex !== -1) {
-						if (!sdpLines[fmtpIndex].includes("x-google-min-bitrate")) sdpLines[fmtpIndex] += `;${bitrateParams}`;
-					} else {
-						for (let k = i; k <= insertAfterIndex; k++) modifiedLines.push(sdpLines[k]);
-						modifiedLines.push(`a=fmtp:${payloadType} ${bitrateParams}`);
-						i = insertAfterIndex;
-						continue;
-					}
-				}
-			}
-			modifiedLines.push(sdpLines[i]);
-		}
-		offer.sdp = modifiedLines.join("\r\n");
-	}
-};
-
-//#endregion
-export { WebRTCConnection };

package/dist/realtime/webrtc-manager.js

@@ -1,210 +0,0 @@
-import { WebRTCConnection } from "./webrtc-connection.js";
-import pRetry, { AbortError } from "p-retry";
-
-//#region src/realtime/webrtc-manager.ts
-const PERMANENT_ERRORS = [
-	"permission denied",
-	"not allowed",
-	"invalid session",
-	"401",
-	"invalid api key",
-	"unauthorized"
-];
-const CONNECTION_TIMEOUT = 6e4 * 5;
-const RETRY_OPTIONS = {
-	retries: 5,
-	factor: 2,
-	minTimeout: 1e3,
-	maxTimeout: 1e4
-};
-var WebRTCManager = class {
-	connection;
-	config;
-	logger;
-	observability;
-	localStream = null;
-	subscribeMode = false;
-	managerState = "disconnected";
-	hasConnected = false;
-	isReconnecting = false;
-	intentionalDisconnect = false;
-	reconnectGeneration = 0;
-	statsProviderConnection = null;
-	constructor(config) {
-		this.config = config;
-		this.logger = config.logger ?? {
-			debug() {},
-			info() {},
-			warn() {},
-			error() {}
-		};
-		this.observability = config.observability;
-		this.connection = new WebRTCConnection({
-			onRemoteStream: config.onRemoteStream,
-			onStateChange: (state) => this.handleConnectionStateChange(state),
-			onError: config.onError,
-			customizeOffer: config.customizeOffer,
-			vp8MinBitrate: config.vp8MinBitrate,
-			vp8StartBitrate: config.vp8StartBitrate,
-			initialImage: config.initialImage,
-			initialPrompt: config.initialPrompt,
-			logger: this.logger,
-			observability: this.observability
-		});
-	}
-	emitState(state) {
-		if (this.managerState !== state) {
-			this.managerState = state;
-			if (state === "connected" || state === "generating") this.hasConnected = true;
-			this.config.onConnectionStateChange?.(state);
-		}
-	}
-	syncStatsProvider() {
-		const pc = this.getPeerConnection();
-		const isLive = this.managerState === "connected" || this.managerState === "generating";
-		if (isLive && pc && pc !== this.statsProviderConnection) {
-			this.statsProviderConnection = pc;
-			this.observability.setStatsProvider(pc);
-		} else if (!isLive && this.statsProviderConnection) {
-			this.statsProviderConnection = null;
-			this.observability.setStatsProvider(null);
-		}
-	}
-	handleConnectionStateChange(state) {
-		if (this.intentionalDisconnect) {
-			this.emitState("disconnected");
-			this.syncStatsProvider();
-			return;
-		}
-		if (this.isReconnecting) {
-			if (state === "connected" || state === "generating") {
-				this.isReconnecting = false;
-				this.emitState(state);
-				this.syncStatsProvider();
-			}
-			return;
-		}
-		if (state === "disconnected" && !this.intentionalDisconnect && this.hasConnected) {
-			this.reconnect();
-			return;
-		}
-		this.emitState(state);
-		this.syncStatsProvider();
-	}
-	async reconnect() {
-		if (this.isReconnecting || this.intentionalDisconnect) return;
-		if (!this.subscribeMode && !this.localStream) return;
-		const reconnectGeneration = ++this.reconnectGeneration;
-		this.isReconnecting = true;
-		this.emitState("reconnecting");
-		this.observability.setStatsProvider(null);
-		this.statsProviderConnection = null;
-		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();
-				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");
-				}
-			}, {
-				...RETRY_OPTIONS,
-				onFailedAttempt: (error) => {
-					if (this.intentionalDisconnect || reconnectGeneration !== this.reconnectGeneration) return;
-					this.logger.warn("Reconnect attempt failed", {
-						error: error.message,
-						attempt: error.attemptNumber
-					});
-					this.observability.diagnostic("reconnect", {
-						attempt: error.attemptNumber,
-						maxAttempts: RETRY_OPTIONS.retries + 1,
-						durationMs: performance.now() - reconnectStart,
-						success: false,
-						error: error.message
-					});
-					this.connection.cleanup();
-				},
-				shouldRetry: (error) => {
-					if (this.intentionalDisconnect || reconnectGeneration !== this.reconnectGeneration) return false;
-					const msg = error.message.toLowerCase();
-					return !PERMANENT_ERRORS.some((err) => msg.includes(err));
-				}
-			});
-			this.observability.diagnostic("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;
-			this.emitState("disconnected");
-			this.config.onError?.(error instanceof Error ? error : new Error(String(error)));
-		}
-	}
-	async connect(localStream) {
-		this.localStream = localStream;
-		this.subscribeMode = localStream === null;
-		this.intentionalDisconnect = false;
-		this.hasConnected = false;
-		this.isReconnecting = false;
-		this.reconnectGeneration += 1;
-		this.emitState("connecting");
-		return pRetry(async () => {
-			if (this.intentionalDisconnect) throw new AbortError("Connect cancelled");
-			await this.connection.connect(this.config.webrtcUrl, localStream, CONNECTION_TIMEOUT, this.config.integration);
-			return true;
-		}, {
-			...RETRY_OPTIONS,
-			onFailedAttempt: (error) => {
-				this.logger.warn("Connection attempt failed", {
-					error: error.message,
-					attempt: error.attemptNumber
-				});
-				this.connection.cleanup();
-			},
-			shouldRetry: (error) => {
-				if (this.intentionalDisconnect) return false;
-				const msg = error.message.toLowerCase();
-				return !PERMANENT_ERRORS.some((err) => msg.includes(err));
-			}
-		});
-	}
-	sendMessage(message) {
-		return this.connection.send(message);
-	}
-	cleanup() {
-		this.intentionalDisconnect = true;
-		this.isReconnecting = false;
-		this.reconnectGeneration += 1;
-		this.connection.cleanup();
-		this.localStream = null;
-		this.statsProviderConnection = null;
-		this.observability.setStatsProvider(null);
-		this.emitState("disconnected");
-	}
-	isConnected() {
-		return this.managerState === "connected" || this.managerState === "generating";
-	}
-	getConnectionState() {
-		return this.managerState;
-	}
-	getPeerConnection() {
-		return this.connection.getPeerConnection();
-	}
-	getWebsocketMessageEmitter() {
-		return this.connection.websocketMessagesEmitter;
-	}
-	setImage(imageBase64, options) {
-		return this.connection.setImageBase64(imageBase64, options);
-	}
-};
-
-//#endregion
-export { WebRTCManager };