@decartai/sdk 0.0.42 → 0.0.44

package/dist/index.d.ts

@@ -4,7 +4,9 @@ import { ProcessClient } from "./process/client.js";
 import { JobStatus, JobStatusResponse, JobSubmitResponse, QueueJobResult, QueueSubmitAndPollOptions, QueueSubmitOptions } from "./queue/types.js";
 import { QueueClient } from "./queue/client.js";
 import { DecartSDKError, ERROR_CODES } from "./utils/errors.js";
-import { AvatarOptions, RealTimeClient, RealTimeClientConnectOptions, RealTimeClientInitialState } from "./realtime/client.js";
+import { ConnectionState } from "./realtime/webrtc-connection.js";
+import { SetInput } from "./realtime/methods.js";
+import { AvatarOptions, Events, RealTimeClient, RealTimeClientConnectOptions, RealTimeClientInitialState } from "./realtime/client.js";
 import { ModelState } from "./shared/types.js";
 import { CreateTokenResponse, TokensClient } from "./tokens/client.js";
 
@@ -117,4 +119,4 @@ declare const createDecartClient: (options?: DecartClientOptions) => {
   tokens: TokensClient;
 };
 //#endregion
-export { type AvatarOptions, type CreateTokenResponse, DecartClientOptions, type DecartSDKError, ERROR_CODES, type FileInput, type ImageModelDefinition, type ImageModels, type JobStatus, type JobStatusResponse, type JobSubmitResponse, type Model, type ModelDefinition, type ModelState, type ProcessClient, type ProcessOptions, type QueueClient, type QueueJobResult, type QueueSubmitAndPollOptions, type QueueSubmitOptions, type ReactNativeFile, type RealTimeClient, type RealTimeClientConnectOptions, type RealTimeClientInitialState, type RealTimeModels, type TokensClient, type VideoModelDefinition, type VideoModels, createDecartClient, isImageModel, isRealtimeModel, isVideoModel, models };
+export { type AvatarOptions, type ConnectionState, type CreateTokenResponse, DecartClientOptions, type DecartSDKError, ERROR_CODES, type FileInput, type ImageModelDefinition, type ImageModels, type JobStatus, type JobStatusResponse, type JobSubmitResponse, type Model, type ModelDefinition, type ModelState, type ProcessClient, type ProcessOptions, type QueueClient, type QueueJobResult, type QueueSubmitAndPollOptions, type QueueSubmitOptions, type ReactNativeFile, type RealTimeClient, type RealTimeClientConnectOptions, type RealTimeClientInitialState, type Events as RealTimeEvents, type RealTimeModels, type SetInput, type TokensClient, type VideoModelDefinition, type VideoModels, createDecartClient, isImageModel, isRealtimeModel, isVideoModel, models };

package/dist/realtime/audio-stream-manager.js

@@ -82,7 +82,7 @@ var AudioStreamManager = class {
 		try {
 			this.silenceOscillator.stop();
 		} catch {}
-		this.audioContext.close();
+		this.audioContext.close().catch(() => {});
 	}
 };
 

package/dist/realtime/client.d.ts

@@ -1,4 +1,5 @@
 import { DecartSDKError } from "../utils/errors.js";
+import { SetInput } from "./methods.js";
 import { z } from "zod";
 
 //#region src/realtime/client.d.ts
@@ -39,17 +40,18 @@ declare const realTimeClientConnectOptionsSchema: z.ZodObject<{
 }, z.core.$strip>;
 type RealTimeClientConnectOptions = z.infer<typeof realTimeClientConnectOptionsSchema>;
 type Events = {
-  connectionChange: "connected" | "connecting" | "disconnected";
+  connectionChange: "connected" | "connecting" | "disconnected" | "reconnecting";
   error: DecartSDKError;
 };
 type RealTimeClient = {
+  set: (input: SetInput) => Promise<void>;
   setPrompt: (prompt: string, {
     enhance
   }?: {
     enhance?: boolean;
   }) => Promise<void>;
   isConnected: () => boolean;
-  getConnectionState: () => "connected" | "connecting" | "disconnected";
+  getConnectionState: () => "connected" | "connecting" | "disconnected" | "reconnecting";
   disconnect: () => void;
   on: <K extends keyof Events>(event: K, listener: (data: Events[K]) => void) => void;
   off: <K extends keyof Events>(event: K, listener: (data: Events[K]) => void) => void;
@@ -62,4 +64,4 @@ type RealTimeClient = {
   playAudio?: (audio: Blob | File | ArrayBuffer) => Promise<void>;
 };
 //#endregion
-export { AvatarOptions, RealTimeClient, RealTimeClientConnectOptions, RealTimeClientInitialState };
+export { AvatarOptions, Events, RealTimeClient, RealTimeClientConnectOptions, RealTimeClientInitialState };

package/dist/realtime/client.js

@@ -13,13 +13,42 @@ async function blobToBase64(blob) {
 	return new Promise((resolve, reject) => {
 		const reader = new FileReader();
 		reader.onloadend = () => {
-			const base64 = reader.result.split(",")[1];
+			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 avatarOptionsSchema = z.object({ avatarImage: z.union([
@@ -49,76 +78,71 @@ const createRealTimeClient = (opts) => {
 			audioStreamManager = new AudioStreamManager();
 			inputStream = audioStreamManager.getStream();
 		} else inputStream = stream ?? new MediaStream();
-		let avatarImageBase64;
-		if (isAvatarLive && avatar?.avatarImage) {
-			let imageBlob;
-			if (typeof avatar.avatarImage === "string") imageBlob = await (await fetch(avatar.avatarImage)).blob();
-			else imageBlob = avatar.avatarImage;
-			avatarImageBase64 = await blobToBase64(imageBlob);
-		}
-		const initialPrompt = isAvatarLive && options.initialState?.prompt ? {
-			text: options.initialState.prompt.text,
-			enhance: options.initialState.prompt.enhance
-		} : void 0;
-		const webrtcManager = new WebRTCManager({
-			webrtcUrl: `${`${baseUrl}${options.model.urlPath}`}?api_key=${apiKey}&model=${options.model.name}`,
-			apiKey,
-			sessionId,
-			fps: options.model.fps,
-			initialState,
-			integration,
-			onRemoteStream,
-			onConnectionStateChange: (state) => {
-				eventEmitter.emit("connectionChange", state);
-			},
-			onError: (error) => {
-				console.error("WebRTC error:", error);
-				eventEmitter.emit("error", createWebrtcError(error));
-			},
-			customizeOffer: options.customizeOffer,
-			vp8MinBitrate: 300,
-			vp8StartBitrate: 600,
-			isAvatarLive,
-			avatarImageBase64,
-			initialPrompt
-		});
-		await webrtcManager.connect(inputStream);
-		const methods = realtimeMethods(webrtcManager);
-		if (!isAvatarLive && options.initialState?.prompt) {
-			const { text, enhance } = options.initialState.prompt;
-			methods.setPrompt(text, { enhance });
-		}
-		const client = {
-			setPrompt: methods.setPrompt,
-			isConnected: () => webrtcManager.isConnected(),
-			getConnectionState: () => webrtcManager.getConnectionState(),
-			disconnect: () => {
-				webrtcManager.cleanup();
-				audioStreamManager?.cleanup();
-			},
-			on: eventEmitter.on,
-			off: eventEmitter.off,
-			sessionId,
-			setImage: async (image, options$1) => {
-				if (image === null) return webrtcManager.setImage(null, options$1);
-				let imageBase64;
-				if (typeof image === "string") {
-					let url = null;
-					try {
-						url = new URL(image);
-					} catch {}
-					if (url?.protocol === "data:") imageBase64 = image.split(",")[1];
-					else if (url?.protocol === "http:" || url?.protocol === "https:") imageBase64 = await blobToBase64(await (await fetch(image)).blob());
-					else imageBase64 = image;
-				} else imageBase64 = await blobToBase64(image);
-				return webrtcManager.setImage(imageBase64, options$1);
+		let webrtcManager;
+		try {
+			let avatarImageBase64;
+			if (isAvatarLive && avatar?.avatarImage) if (typeof avatar.avatarImage === "string") {
+				const response = await fetch(avatar.avatarImage);
+				if (!response.ok) throw new Error(`Failed to fetch image: ${response.status} ${response.statusText}`);
+				avatarImageBase64 = await blobToBase64(await response.blob());
+			} else avatarImageBase64 = await blobToBase64(avatar.avatarImage);
+			const initialPrompt = isAvatarLive && initialState?.prompt ? {
+				text: initialState.prompt.text,
+				enhance: initialState.prompt.enhance
+			} : void 0;
+			webrtcManager = new WebRTCManager({
+				webrtcUrl: `${`${baseUrl}${options.model.urlPath}`}?api_key=${encodeURIComponent(apiKey)}&model=${encodeURIComponent(options.model.name)}`,
+				integration,
+				onRemoteStream,
+				onConnectionStateChange: (state) => {
+					eventEmitter.emit("connectionChange", state);
+				},
+				onError: (error) => {
+					console.error("WebRTC error:", error);
+					eventEmitter.emit("error", createWebrtcError(error));
+				},
+				customizeOffer: options.customizeOffer,
+				vp8MinBitrate: 300,
+				vp8StartBitrate: 600,
+				isAvatarLive,
+				avatarImageBase64,
+				initialPrompt
+			});
+			const manager = webrtcManager;
+			await manager.connect(inputStream);
+			const methods = realtimeMethods(manager, imageToBase64);
+			if (!isAvatarLive && initialState?.prompt) {
+				const { text, enhance } = initialState.prompt;
+				await methods.setPrompt(text, { enhance });
 			}
-		};
-		if (isAvatarLive && audioStreamManager) {
-			const manager = audioStreamManager;
-			client.playAudio = (audio) => manager.playAudio(audio);
+			const client = {
+				set: methods.set,
+				setPrompt: methods.setPrompt,
+				isConnected: () => manager.isConnected(),
+				getConnectionState: () => manager.getConnectionState(),
+				disconnect: () => {
+					manager.cleanup();
+					audioStreamManager?.cleanup();
+				},
+				on: eventEmitter.on,
+				off: eventEmitter.off,
+				sessionId,
+				setImage: async (image, options$1) => {
+					if (image === null) return manager.setImage(null, options$1);
+					const base64 = await imageToBase64(image);
+					return manager.setImage(base64, options$1);
+				}
+			};
+			if (isAvatarLive && audioStreamManager) {
+				const manager$1 = audioStreamManager;
+				client.playAudio = (audio) => manager$1.playAudio(audio);
+			}
+			return client;
+		} catch (error) {
+			webrtcManager?.cleanup();
+			audioStreamManager?.cleanup();
+			throw error;
 		}
-		return client;
 	};
 	return { connect };
 };

package/dist/realtime/methods.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+
+//#region src/realtime/methods.d.ts
+declare const setInputSchema: z.ZodObject<{
+  prompt: z.ZodOptional<z.ZodString>;
+  enhance: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+  image: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<Blob, Blob>, z.ZodCustom<File, File>, z.ZodString, z.ZodNull]>>;
+}, z.core.$strip>;
+type SetInput = z.input<typeof setInputSchema>;
+//#endregion
+export { SetInput };

package/dist/realtime/methods.js

@@ -2,12 +2,42 @@ import { z } from "zod";
 
 //#region src/realtime/methods.ts
 const PROMPT_TIMEOUT_MS = 15 * 1e3;
-const realtimeMethods = (webrtcManager) => {
+const UPDATE_TIMEOUT_MS = 30 * 1e3;
+const setInputSchema = z.object({
+	prompt: z.string().min(1).optional(),
+	enhance: z.boolean().optional().default(true),
+	image: z.union([
+		z.instanceof(Blob),
+		z.instanceof(File),
+		z.string(),
+		z.null()
+	]).optional()
+}).refine((data) => data.prompt !== void 0 || data.image !== void 0, { message: "At least one of 'prompt' or 'image' must be provided" });
+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") throw new Error(`Cannot send message: connection is ${state}`);
+	};
+	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, {
+			prompt,
+			enhance,
+			timeout: UPDATE_TIMEOUT_MS
+		});
+	};
 	const setPrompt = async (prompt, { enhance } = {}) => {
-		const parsedInput = z.object({
-			prompt: z.string().min(1),
-			enhance: z.boolean().optional().default(true)
-		}).safeParse({
+		assertConnected();
+		const parsedInput = setPromptInputSchema.safeParse({
 			prompt,
 			enhance
 		});
@@ -19,15 +49,15 @@ const realtimeMethods = (webrtcManager) => {
 			const ackPromise = new Promise((resolve, reject) => {
 				promptAckListener = (promptAckMessage) => {
 					if (promptAckMessage.prompt === parsedInput.data.prompt) if (promptAckMessage.success) resolve();
-					else reject(promptAckMessage.error);
+					else reject(new Error(promptAckMessage.error ?? "Failed to send prompt"));
 				};
 				emitter.on("promptAck", promptAckListener);
 			});
-			webrtcManager.sendMessage({
+			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);
 			});
@@ -37,7 +67,10 @@ const realtimeMethods = (webrtcManager) => {
 			if (timeoutId) clearTimeout(timeoutId);
 		}
 	};
-	return { setPrompt };
+	return {
+		set,
+		setPrompt
+	};
 };
 
 //#endregion

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

@@ -0,0 +1,7 @@
+import "mitt";
+
+//#region src/realtime/webrtc-connection.d.ts
+
+type ConnectionState = "connecting" | "connected" | "disconnected" | "reconnecting";
+//#endregion
+export { ConnectionState };

package/dist/realtime/webrtc-connection.js

@@ -19,43 +19,61 @@ var WebRTCConnection = class {
 		this.localStream = localStream;
 		const userAgent = encodeURIComponent(buildUserAgent(integration));
 		const wsUrl = `${url}${url.includes("?") ? "&" : "?"}user_agent=${userAgent}`;
-		await new Promise((resolve, reject) => {
-			this.connectionReject = reject;
-			const timer = setTimeout(() => reject(/* @__PURE__ */ new Error("WebSocket timeout")), timeout);
-			this.ws = new WebSocket(wsUrl);
-			this.ws.onopen = () => {
-				clearTimeout(timer);
-				resolve();
-			};
-			this.ws.onmessage = (e) => {
-				try {
-					this.handleSignalingMessage(JSON.parse(e.data));
-				} catch (err) {
-					console.error("[WebRTC] Parse error:", err);
-				}
-			};
-			this.ws.onerror = () => {
-				clearTimeout(timer);
-			};
-			this.ws.onclose = () => this.setState("disconnected");
+		let rejectConnect;
+		const connectAbort = new Promise((_, reject) => {
+			rejectConnect = reject;
 		});
-		if (this.callbacks.avatarImageBase64) await this.sendAvatarImage(this.callbacks.avatarImageBase64);
-		if (this.callbacks.initialPrompt) await this.sendInitialPrompt(this.callbacks.initialPrompt);
-		await this.setupNewPeerConnection();
-		return new Promise((resolve, reject) => {
-			this.connectionReject = reject;
-			const checkConnection = setInterval(() => {
-				if (this.state === "connected") {
-					clearInterval(checkConnection);
-					this.connectionReject = null;
+		connectAbort.catch(() => {});
+		this.connectionReject = (error) => rejectConnect(error);
+		try {
+			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);
 					resolve();
-				} else if (Date.now() >= deadline) {
-					clearInterval(checkConnection);
-					this.connectionReject = null;
-					reject(/* @__PURE__ */ new Error("Connection timeout"));
-				}
-			}, 100);
-		});
+				};
+				this.ws.onmessage = (e) => {
+					try {
+						this.handleSignalingMessage(JSON.parse(e.data));
+					} catch (err) {
+						console.error("[WebRTC] Parse error:", err);
+					}
+				};
+				this.ws.onerror = () => {
+					clearTimeout(timer);
+					const error = /* @__PURE__ */ new Error("WebSocket error");
+					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.avatarImageBase64) await Promise.race([this.sendAvatarImage(this.callbacks.avatarImageBase64), connectAbort]);
+			if (this.callbacks.initialPrompt) await Promise.race([this.sendInitialPrompt(this.callbacks.initialPrompt), connectAbort]);
+			await this.setupNewPeerConnection();
+			await Promise.race([new Promise((resolve, reject) => {
+				const checkConnection = setInterval(() => {
+					if (this.state === "connected") {
+						clearInterval(checkConnection);
+						resolve();
+					} else if (this.state === "disconnected") {
+						clearInterval(checkConnection);
+						reject(/* @__PURE__ */ new Error("Connection lost during WebRTC handshake"));
+					} else if (Date.now() >= deadline) {
+						clearInterval(checkConnection);
+						reject(/* @__PURE__ */ new Error("Connection timeout"));
+					}
+				}, 100);
+				connectAbort.catch(() => clearInterval(checkConnection));
+			}), connectAbort]);
+		} finally {
+			this.connectionReject = null;
+		}
 	}
 	async handleSignalingMessage(msg) {
 		try {
@@ -121,10 +139,16 @@ var WebRTCConnection = class {
 		} catch (error) {
 			console.error("[WebRTC] Error:", error);
 			this.callbacks.onError?.(error);
+			this.connectionReject?.(error);
 		}
 	}
 	send(message) {
-		if (this.ws?.readyState === WebSocket.OPEN) this.ws.send(JSON.stringify(message));
+		if (this.ws?.readyState === WebSocket.OPEN) {
+			this.ws.send(JSON.stringify(message));
+			return true;
+		}
+		console.warn("[WebRTC] Message dropped: WebSocket is not open");
+		return false;
 	}
 	async sendAvatarImage(imageBase64) {
 		return this.setImageBase64(imageBase64);
@@ -154,7 +178,11 @@ var WebRTCConnection = class {
 			};
 			if (options?.prompt !== void 0) message.prompt = options.prompt;
 			if (options?.enhance !== void 0) message.enhance_prompt = options.enhance;
-			this.send(message);
+			if (!this.send(message)) {
+				clearTimeout(timeoutId);
+				this.websocketMessagesEmitter.off("setImageAck", listener);
+				reject(/* @__PURE__ */ new Error("WebSocket is not open"));
+			}
 		});
 	}
 	/**
@@ -175,11 +203,15 @@ var WebRTCConnection = class {
 				}
 			};
 			this.websocketMessagesEmitter.on("promptAck", listener);
-			this.send({
+			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) {
@@ -196,13 +228,14 @@ var WebRTCConnection = class {
 			});
 			this.pc.close();
 		}
-		const iceServers = ICE_SERVERS;
+		const iceServers = [...ICE_SERVERS];
 		if (turnConfig) iceServers.push({
 			urls: turnConfig.server_url,
 			credential: turnConfig.credential,
 			username: turnConfig.username
 		});
 		this.pc = new RTCPeerConnection({ iceServers });
+		this.setState("connecting");
 		if (this.callbacks.isAvatarLive) this.pc.addTransceiver("video", { direction: "recvonly" });
 		this.localStream.getTracks().forEach((track) => {
 			if (this.pc && this.localStream) this.pc.addTrack(track, this.localStream);
@@ -221,7 +254,12 @@ var WebRTCConnection = class {
 			const s = this.pc.connectionState;
 			this.setState(s === "connected" ? "connected" : ["connecting", "new"].includes(s) ? "connecting" : "disconnected");
 		};
-		this.pc.oniceconnectionstatechange = () => {};
+		this.pc.oniceconnectionstatechange = () => {
+			if (this.pc?.iceConnectionState === "failed") {
+				this.setState("disconnected");
+				this.callbacks.onError?.(/* @__PURE__ */ new Error("ICE connection failed"));
+			}
+		};
 		this.handleSignalingMessage({ type: "ready" });
 	}
 	cleanup() {
@@ -232,8 +270,12 @@ var WebRTCConnection = class {
 		this.localStream = null;
 		this.setState("disconnected");
 	}
-	async applyCodecPreference(preferredCodecName) {
+	applyCodecPreference(preferredCodecName) {
 		if (!this.pc) return;
+		if (typeof RTCRtpSender === "undefined" || typeof RTCRtpSender.getCapabilities !== "function") {
+			console.warn("RTCRtpSender capabilities are 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.");
@@ -255,12 +297,17 @@ var WebRTCConnection = class {
 			console.warn("No video codecs found to set preferences for.");
 			return;
 		}
-		await videoTransceiver.setCodecPreferences(orderedCodecs);
+		try {
+			videoTransceiver.setCodecPreferences(orderedCodecs);
+		} catch {
+			console.warn("[WebRTC] setCodecPreferences not supported, skipping codec preference.");
+		}
 	}
 	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");

package/dist/realtime/webrtc-manager.js

@@ -1,5 +1,5 @@
 import { WebRTCConnection } from "./webrtc-connection.js";
-import pRetry from "p-retry";
+import pRetry, { AbortError } from "p-retry";
 
 //#region src/realtime/webrtc-manager.ts
 const PERMANENT_ERRORS = [
@@ -10,14 +10,27 @@ const PERMANENT_ERRORS = [
 	"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;
+	localStream = null;
+	managerState = "disconnected";
+	hasConnected = false;
+	isReconnecting = false;
+	intentionalDisconnect = false;
+	reconnectGeneration = 0;
 	constructor(config) {
 		this.config = config;
 		this.connection = new WebRTCConnection({
 			onRemoteStream: config.onRemoteStream,
-			onStateChange: config.onConnectionStateChange,
+			onStateChange: (state) => this.handleConnectionStateChange(state),
 			onError: config.onError,
 			customizeOffer: config.customizeOffer,
 			vp8MinBitrate: config.vp8MinBitrate,
@@ -27,36 +40,107 @@ var WebRTCManager = class {
 			initialPrompt: config.initialPrompt
 		});
 	}
+	emitState(state) {
+		if (this.managerState !== state) {
+			this.managerState = state;
+			if (state === "connected") this.hasConnected = true;
+			this.config.onConnectionStateChange?.(state);
+		}
+	}
+	handleConnectionStateChange(state) {
+		if (this.intentionalDisconnect) {
+			this.emitState("disconnected");
+			return;
+		}
+		if (this.isReconnecting) {
+			if (state === "connected") {
+				this.isReconnecting = false;
+				this.emitState("connected");
+			}
+			return;
+		}
+		if (state === "disconnected" && !this.intentionalDisconnect && this.hasConnected) {
+			this.reconnect();
+			return;
+		}
+		this.emitState(state);
+	}
+	async reconnect() {
+		if (this.isReconnecting || this.intentionalDisconnect || !this.localStream) return;
+		const reconnectGeneration = ++this.reconnectGeneration;
+		this.isReconnecting = true;
+		this.emitState("reconnecting");
+		try {
+			await pRetry(async () => {
+				if (this.intentionalDisconnect || reconnectGeneration !== this.reconnectGeneration) throw new AbortError("Reconnect cancelled");
+				const stream = this.localStream;
+				if (!stream) throw new AbortError("Reconnect cancelled: no local stream");
+				this.connection.cleanup();
+				await this.connection.connect(this.config.webrtcUrl, stream, 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;
+					console.error(`[WebRTC] Reconnect attempt failed: ${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));
+				}
+			});
+		} 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.intentionalDisconnect = false;
+		this.hasConnected = false;
+		this.isReconnecting = false;
+		this.reconnectGeneration += 1;
+		this.emitState("connecting");
 		return pRetry(async () => {
-			await this.connection.connect(this.config.webrtcUrl, localStream, 6e4 * 5, this.config.integration);
+			if (this.intentionalDisconnect) throw new AbortError("Connect cancelled");
+			await this.connection.connect(this.config.webrtcUrl, localStream, CONNECTION_TIMEOUT, this.config.integration);
 			return true;
 		}, {
-			retries: 5,
-			factor: 2,
-			minTimeout: 1e3,
-			maxTimeout: 1e4,
+			...RETRY_OPTIONS,
 			onFailedAttempt: (error) => {
 				console.error(`[WebRTC] Failed to connect: ${error.message}`);
 				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) {
-		this.connection.send(message);
+		return this.connection.send(message);
 	}
 	cleanup() {
+		this.intentionalDisconnect = true;
+		this.isReconnecting = false;
+		this.reconnectGeneration += 1;
 		this.connection.cleanup();
+		this.localStream = null;
+		this.emitState("disconnected");
 	}
 	isConnected() {
-		return this.connection.state === "connected";
+		return this.managerState === "connected";
 	}
 	getConnectionState() {
-		return this.connection.state;
+		return this.managerState;
 	}
 	getWebsocketMessageEmitter() {
 		return this.connection.websocketMessagesEmitter;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decartai/sdk",
-  "version": "0.0.42",
+  "version": "0.0.44",
   "description": "Decart's JavaScript SDK",
   "type": "module",
   "license": "MIT",