@decartai/sdk 0.0.67 → 0.1.0

package/dist/realtime/webrtc-manager.js

@@ -1,189 +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;
-	localStream = null;
-	subscribeMode = false;
-	managerState = "disconnected";
-	hasConnected = false;
-	isReconnecting = false;
-	intentionalDisconnect = false;
-	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),
-			onError: config.onError,
-			customizeOffer: config.customizeOffer,
-			vp8MinBitrate: config.vp8MinBitrate,
-			vp8StartBitrate: config.vp8StartBitrate,
-			initialImage: config.initialImage,
-			initialPrompt: config.initialPrompt,
-			logger: this.logger,
-			onDiagnostic: config.onDiagnostic
-		});
-	}
-	emitState(state) {
-		if (this.managerState !== state) {
-			this.managerState = state;
-			if (state === "connected" || state === "generating") this.hasConnected = true;
-			this.config.onConnectionStateChange?.(state);
-		}
-	}
-	handleConnectionStateChange(state) {
-		if (this.intentionalDisconnect) {
-			this.emitState("disconnected");
-			return;
-		}
-		if (this.isReconnecting) {
-			if (state === "connected" || state === "generating") {
-				this.isReconnecting = false;
-				this.emitState(state);
-			}
-			return;
-		}
-		if (state === "disconnected" && !this.intentionalDisconnect && this.hasConnected) {
-			this.reconnect();
-			return;
-		}
-		this.emitState(state);
-	}
-	async reconnect() {
-		if (this.isReconnecting || this.intentionalDisconnect) return;
-		if (!this.subscribeMode && !this.localStream) return;
-		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();
-				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.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) => {
-					if (this.intentionalDisconnect || reconnectGeneration !== this.reconnectGeneration) return false;
-					const msg = error.message.toLowerCase();
-					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;
-			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.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 };

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

@@ -1,59 +0,0 @@
-//#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

@@ -1,154 +0,0 @@
-//#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 };