@convai/web-sdk 1.5.0-beta.0 → 1.6.0-beta.0

package/dist/core/VideoManager.js

@@ -1,9 +1,10 @@
+import { Track } from "livekit-client";
 import { logger } from "../utils/logger";
 import { EventEmitter } from "./EventEmitter";
+import { isWebcamVisionSource, shouldKeepExistingVisionSource, } from "./videoSourceState";
 /**
- * Manages video controls for LiveKit room
- * Provides methods to enable/disable camera, manage video devices,
- * and control video state.
+ * Manages visual source controls. LiveKit publishes real video tracks;
+ * WebSocket samples active sources into vision-frame messages.
  */
 export class VideoManager extends EventEmitter {
     constructor(room) {
@@ -11,6 +12,10 @@ export class VideoManager extends EventEmitter {
         this.room = null;
         this._isVideoEnabled = false;
         this._isVideoHidden = false;
+        this._activeVisionSource = null;
+        this.pendingVisionSourceTracks = new WeakMap();
+        this.webSocketVisionMessageSender = null;
+        this.webSocketVisionMode = "off";
         if (room) {
             this.setRoom(room);
         }
@@ -21,6 +26,15 @@ export class VideoManager extends EventEmitter {
     get isVideoHidden() {
         return this._isVideoHidden;
     }
+    get activeVisionSource() {
+        return this.getLiveVisionSource();
+    }
+    get hasActiveVisionSource() {
+        return this.activeVisionSource !== null;
+    }
+    get visionSourceState() {
+        return this.makeVisionSourceState();
+    }
     /**
      * Set the LiveKit room instance
      */
@@ -30,11 +44,27 @@ export class VideoManager extends EventEmitter {
             this.cleanupListeners();
         }
         this.room = room;
-        if (room && room.state !== 'disconnected') {
+        if (room) {
             this.setupListeners();
             this.updateState();
         }
     }
+    setWebSocketVisionMessageSender(sender) {
+        this.webSocketVisionMessageSender = sender;
+        this.webSocketVisionMode = sender ? "enabled" : "off";
+    }
+    setWebSocketVisionDisabled() {
+        this.webSocketVisionMessageSender = null;
+        this.webSocketVisionMode = "disabled";
+        const activeSource = this._activeVisionSource;
+        activeSource?.cleanup?.();
+        if (activeSource?.stopTrackOnUnpublish &&
+            activeSource.track.readyState !== "ended") {
+            activeSource.track.stop();
+        }
+        this._activeVisionSource = null;
+        this._isVideoEnabled = false;
+    }
     /**
      * Setup event listeners for room
      */
@@ -43,33 +73,43 @@ export class VideoManager extends EventEmitter {
             return;
         const localParticipant = this.room.localParticipant;
         const handleTrackMuted = (track) => {
-            if (track.source === 'camera') {
+            if (this.isWebcamPublication(track)) {
                 this._isVideoHidden = true;
-                this.emit('videoStateChange', { isVideoHidden: true });
+                this.emitVideoStateChange("track_muted", { isVideoHidden: true });
             }
         };
         const handleTrackUnmuted = (track) => {
-            if (track.source === 'camera') {
+            if (this.isWebcamPublication(track)) {
                 this._isVideoHidden = false;
-                this.emit('videoStateChange', { isVideoHidden: false });
+                this.emitVideoStateChange("track_unmuted", { isVideoHidden: false });
             }
         };
         const handleTrackPublished = (publication) => {
-            if (publication.source === 'camera') {
+            if (this.isWebcamPublication(publication)) {
                 this._isVideoEnabled = true;
-                this.emit('videoStateChange', { isVideoEnabled: true });
+                if (!this._activeVisionSource) {
+                    const handle = this.createPublicationHandle(publication, "webcam", "webcam", false);
+                    if (handle) {
+                        this.setActiveVisionSource(handle);
+                    }
+                }
+                this.emitVideoStateChange("track_published", { isVideoEnabled: true });
             }
         };
         const handleTrackUnpublished = (publication) => {
-            if (publication.source === 'camera') {
-                this._isVideoEnabled = false;
-                this.emit('videoStateChange', { isVideoEnabled: false });
+            if (this.isCameraLikeSource(publication?.source)) {
+                const isWebcam = this.isWebcamPublication(publication);
+                this.clearActiveVisionSourceForPublication(publication, isWebcam ? "track_unpublished" : "vision_source_unpublished");
+                this.updateState();
+                this.emitVideoStateChange(isWebcam ? "track_unpublished" : "vision_source_unpublished", {
+                    isVideoEnabled: this._isVideoEnabled,
+                });
             }
         };
-        localParticipant.on('trackMuted', handleTrackMuted);
-        localParticipant.on('trackUnmuted', handleTrackUnmuted);
-        localParticipant.on('trackPublished', handleTrackPublished);
-        localParticipant.on('trackUnpublished', handleTrackUnpublished);
+        localParticipant.on("trackMuted", handleTrackMuted);
+        localParticipant.on("trackUnmuted", handleTrackUnmuted);
+        localParticipant.on("trackPublished", handleTrackPublished);
+        localParticipant.on("trackUnpublished", handleTrackUnpublished);
     }
     /**
      * Clean up event listeners
@@ -83,26 +123,67 @@ export class VideoManager extends EventEmitter {
      * Update video state from room
      */
     updateState() {
-        if (!this.room || this.room.state === 'disconnected') {
+        if (!this.room || this.room.state === "disconnected") {
             this._isVideoEnabled = false;
             this._isVideoHidden = false;
+            this._activeVisionSource?.cleanup?.();
+            this._activeVisionSource = null;
             return;
         }
+        let activeSource = this.getLiveVisionSource();
         const localParticipant = this.room.localParticipant;
-        this._isVideoEnabled = localParticipant.isCameraEnabled;
+        if (!activeSource && localParticipant.isCameraEnabled) {
+            const handle = this.createPublicationHandle(localParticipant.getTrackPublication(Track.Source.Camera), "webcam", "webcam", false);
+            if (handle) {
+                this.setActiveVisionSource(handle);
+                activeSource = handle;
+            }
+        }
+        this._isVideoEnabled =
+            isWebcamVisionSource(activeSource?.source) ||
+                (!activeSource && localParticipant.isCameraEnabled);
         this._isVideoHidden = false; // LiveKit doesn't have a direct hidden state for video
     }
     /**
      * Enable video
      */
     async enableVideo() {
+        if (this.isWebSocketVisionTransport()) {
+            this.assertWebSocketVisionEnabled();
+            const stream = await navigator.mediaDevices.getUserMedia({
+                video: true,
+                audio: false,
+            });
+            const track = stream.getVideoTracks()[0];
+            if (!track) {
+                throw new Error("getUserMedia() produced no video track");
+            }
+            try {
+                await this.publishVideoTrack(track, {
+                    name: "webcam",
+                    source: "webcam",
+                    stopTrackOnUnpublish: true,
+                });
+            }
+            catch (error) {
+                track.stop();
+                throw error;
+            }
+            return;
+        }
         if (!this.room) {
-            throw new Error('Room not initialized');
+            throw new Error("Room not initialized");
         }
         try {
-            await this.room.localParticipant.setCameraEnabled(true);
+            await this.replaceActiveVisionSource({ source: "webcam" });
+            const publication = await this.room.localParticipant.setCameraEnabled(true);
             this._isVideoEnabled = true;
-            this.emit('videoStateChange', { isVideoEnabled: true });
+            const handle = this.createPublicationHandle(publication ||
+                this.room.localParticipant.getTrackPublication(Track.Source.Camera), "webcam", "webcam", false);
+            if (handle) {
+                this.setActiveVisionSource(handle);
+            }
+            this.emitVideoStateChange("webcam_enabled", { isVideoEnabled: true });
         }
         catch (error) {
             throw error;
@@ -112,13 +193,32 @@ export class VideoManager extends EventEmitter {
      * Disable video
      */
     async disableVideo() {
+        if (this.isWebSocketVisionTransport()) {
+            const activeSource = this._activeVisionSource;
+            if (activeSource) {
+                await this.unpublishVisionSource(activeSource);
+            }
+            this._isVideoEnabled = false;
+            this.emitVideoStateChange("webcam_disabled", { isVideoEnabled: false });
+            return;
+        }
         if (!this.room) {
-            throw new Error('Room not initialized');
+            throw new Error("Room not initialized");
         }
         try {
             await this.room.localParticipant.setCameraEnabled(false);
             this._isVideoEnabled = false;
-            this.emit('videoStateChange', { isVideoEnabled: false });
+            const activeSource = this._activeVisionSource;
+            if (activeSource) {
+                if (isWebcamVisionSource(activeSource.source)) {
+                    activeSource.cleanup?.();
+                    this._activeVisionSource = null;
+                }
+                else {
+                    await this.unpublishVisionSource(activeSource);
+                }
+            }
+            this.emitVideoStateChange("webcam_disabled", { isVideoEnabled: false });
         }
         catch (error) {
             throw error;
@@ -151,11 +251,46 @@ export class VideoManager extends EventEmitter {
      * Set video device
      */
     async setVideoDevice(deviceId) {
+        if (this.isWebSocketVisionTransport()) {
+            this.assertWebSocketVisionEnabled();
+            const stream = await navigator.mediaDevices.getUserMedia({
+                video: { deviceId: { exact: deviceId } },
+                audio: false,
+            });
+            const track = stream.getVideoTracks()[0];
+            if (!track) {
+                throw new Error("getUserMedia() produced no video track");
+            }
+            try {
+                await this.publishVideoTrack(track, {
+                    name: "webcam",
+                    source: "webcam",
+                    stopTrackOnUnpublish: true,
+                });
+            }
+            catch (error) {
+                track.stop();
+                throw error;
+            }
+            return;
+        }
         if (!this.room) {
-            throw new Error('Room not initialized');
+            throw new Error("Room not initialized");
         }
         try {
-            await this.room.localParticipant.setCameraEnabled(true, { deviceId });
+            await this.replaceActiveVisionSource({ source: "webcam" });
+            const publication = await this.room.localParticipant.setCameraEnabled(true, {
+                deviceId,
+            });
+            const handle = this.createPublicationHandle(publication ||
+                this.room.localParticipant.getTrackPublication(Track.Source.Camera), "webcam", "webcam", false);
+            if (handle) {
+                this.setActiveVisionSource(handle);
+            }
+            this._isVideoEnabled = true;
+            this.emitVideoStateChange("webcam_device_selected", {
+                isVideoEnabled: true,
+            });
         }
         catch (error) {
             logger.error("Failed to set video device:", error);
@@ -168,7 +303,7 @@ export class VideoManager extends EventEmitter {
     async getVideoDevices() {
         try {
             const devices = await navigator.mediaDevices.enumerateDevices();
-            const videoDevices = devices.filter(device => device.kind === 'videoinput');
+            const videoDevices = devices.filter((device) => device.kind === "videoinput");
             return videoDevices;
         }
         catch (error) {
@@ -180,8 +315,12 @@ export class VideoManager extends EventEmitter {
      * Set video quality
      */
     async setVideoQuality(quality) {
+        if (this.isWebSocketVisionTransport()) {
+            this.assertWebSocketVisionEnabled();
+            return;
+        }
         if (!this.room) {
-            throw new Error('Room not initialized');
+            throw new Error("Room not initialized");
         }
         try {
             // TODO: Implement video quality settings when LiveKit provides the API
@@ -190,15 +329,425 @@ export class VideoManager extends EventEmitter {
             throw error;
         }
     }
+    async publishCanvas(canvas, options = {}) {
+        const captureStream = canvas.captureStream;
+        if (typeof captureStream !== "function") {
+            throw new Error("Canvas captureStream() is not supported in this browser");
+        }
+        const stream = canvas.captureStream(options.fps ?? 1);
+        const track = stream.getVideoTracks()[0];
+        if (!track) {
+            throw new Error("Canvas captureStream() produced no video track");
+        }
+        try {
+            return await this.publishVideoTrack(track, {
+                name: options.name ?? "canvas-pov",
+                source: options.source ?? "canvas",
+                fps: options.fps,
+                stopTrackOnUnpublish: options.stopTrackOnUnpublish ?? true,
+            });
+        }
+        catch (error) {
+            if (track.readyState !== "ended") {
+                track.stop();
+            }
+            throw error;
+        }
+    }
+    async publishVideoTrack(track, options = {}) {
+        if (this.isWebSocketVisionTransport()) {
+            this.assertWebSocketVisionEnabled();
+            return this.publishWebSocketVideoTrack(track, options);
+        }
+        if (!this.room) {
+            throw new Error("Room not initialized");
+        }
+        const source = options.source ?? "custom";
+        const sourceName = options.name ?? source;
+        const publicationName = sourceName.toLowerCase().includes(source.toLowerCase())
+            ? sourceName
+            : `${source}:${sourceName}`;
+        const stopTrackOnUnpublish = options.stopTrackOnUnpublish ?? false;
+        await this.replaceActiveVisionSource({ source, track });
+        this.pendingVisionSourceTracks.set(track, source);
+        let publication;
+        try {
+            publication = await this.room.localParticipant.publishTrack(track, {
+                name: publicationName,
+                source: this.toLiveKitSource(source),
+            });
+        }
+        catch (error) {
+            this.pendingVisionSourceTracks.delete(track);
+            throw error;
+        }
+        const handle = {
+            track,
+            publication,
+            transport: "livekit",
+            sourceName,
+            source,
+            stopTrackOnUnpublish,
+            unpublish: async () => this.unpublishVisionSource(handle),
+        };
+        this.addTrackEndedListener(handle);
+        this.setActiveVisionSource(handle);
+        this._isVideoEnabled = isWebcamVisionSource(source);
+        this.emitVideoStateChange("vision_source_published", {
+            isVideoEnabled: this._isVideoEnabled,
+        });
+        return handle;
+    }
+    async unpublishVisionSource(source) {
+        const handle = this.resolveVisionSource(source);
+        if (!handle)
+            return;
+        if (handle.transport === "websocket") {
+            const wasActive = this._activeVisionSource?.track === handle.track;
+            handle.cleanup?.();
+            if (handle.stopTrackOnUnpublish && handle.track.readyState !== "ended") {
+                handle.track.stop();
+            }
+            if (wasActive) {
+                this._activeVisionSource = null;
+                if (isWebcamVisionSource(handle.source)) {
+                    this._isVideoEnabled = false;
+                }
+                this.sendWebSocketVisionSourceState(false, handle.source);
+                this.emitVideoStateChange("vision_source_unpublished", {
+                    isVideoEnabled: this._isVideoEnabled,
+                });
+            }
+            return;
+        }
+        if (!this.room) {
+            throw new Error("Room not initialized");
+        }
+        await this.room.localParticipant.unpublishTrack(handle.track, handle.stopTrackOnUnpublish);
+        if (handle.stopTrackOnUnpublish && handle.track.readyState !== "ended") {
+            handle.track.stop();
+        }
+        if (this._activeVisionSource?.track === handle.track) {
+            this._activeVisionSource.cleanup?.();
+            this._activeVisionSource = null;
+        }
+        this.updateState();
+        this.emitVideoStateChange("vision_source_unpublished", {
+            isVideoEnabled: this._isVideoEnabled,
+        });
+    }
+    async publishWebSocketVideoTrack(track, options = {}) {
+        const source = options.source ?? "custom";
+        const sourceName = options.name ?? source;
+        const stopTrackOnUnpublish = options.stopTrackOnUnpublish ?? false;
+        const fps = this.normalizeWebSocketFps(options.fps ?? 1);
+        const activeSource = this._activeVisionSource;
+        if (activeSource?.track === track) {
+            activeSource.cleanup?.();
+            this._activeVisionSource = null;
+        }
+        else {
+            await this.replaceActiveVisionSource({ source, track });
+        }
+        const stream = new MediaStream([track]);
+        const video = document.createElement("video");
+        video.muted = true;
+        video.playsInline = true;
+        video.srcObject = stream;
+        const canvas = document.createElement("canvas");
+        const context = canvas.getContext("2d");
+        if (!context) {
+            throw new Error("Unable to create canvas context for WebSocket vision");
+        }
+        let intervalId = null;
+        let stopped = false;
+        let captureWarningLogged = false;
+        let handle;
+        const publishFrame = () => {
+            if (stopped)
+                return;
+            if (track.readyState !== "live") {
+                this.clearEndedVisionSource(handle);
+                return;
+            }
+            if (!this.webSocketVisionMessageSender)
+                return;
+            const width = video.videoWidth || track.getSettings?.().width || 0;
+            const height = video.videoHeight || track.getSettings?.().height || 0;
+            if (!width || !height)
+                return;
+            try {
+                if (canvas.width !== width)
+                    canvas.width = width;
+                if (canvas.height !== height)
+                    canvas.height = height;
+                context.drawImage(video, 0, 0, width, height);
+                this.webSocketVisionMessageSender("vision-frame", {
+                    image: canvas.toDataURL("image/jpeg", 0.82),
+                    source_label: this.toBackendVisionSourceLabel(source),
+                    capture_pts_ns: String(Math.round(performance.now() * 1000000)),
+                });
+            }
+            catch (error) {
+                if (!captureWarningLogged) {
+                    captureWarningLogged = true;
+                    logger.warn("Unable to capture WebSocket vision frame:", error);
+                }
+            }
+        };
+        const cleanupCapture = () => {
+            stopped = true;
+            if (intervalId !== null) {
+                window.clearInterval(intervalId);
+                intervalId = null;
+            }
+            video.pause();
+            video.srcObject = null;
+        };
+        handle = {
+            track,
+            transport: "websocket",
+            sourceName,
+            source,
+            stopTrackOnUnpublish,
+            unpublish: async () => this.unpublishVisionSource(handle),
+            cleanup: cleanupCapture,
+        };
+        this.addTrackEndedListener(handle);
+        this.setActiveVisionSource(handle);
+        this._isVideoEnabled = isWebcamVisionSource(source);
+        this.emitVideoStateChange("vision_source_published", {
+            isVideoEnabled: this._isVideoEnabled,
+        });
+        this.sendWebSocketVisionSourceState(true, source);
+        try {
+            await video.play();
+        }
+        catch (error) {
+            logger.warn("WebSocket vision video playback did not start immediately:", error);
+        }
+        publishFrame();
+        if (!stopped) {
+            intervalId = window.setInterval(publishFrame, Math.round(1000 / fps));
+        }
+        return handle;
+    }
+    resolveVisionSource(source) {
+        if (!source)
+            return this._activeVisionSource;
+        if ("track" in source)
+            return source;
+        if (this._activeVisionSource?.track === source) {
+            return this._activeVisionSource;
+        }
+        return {
+            track: source,
+            sourceName: source.label || "custom",
+            source: "custom",
+            transport: this.isWebSocketVisionTransport() ? "websocket" : "livekit",
+            stopTrackOnUnpublish: false,
+            unpublish: async () => this.unpublishVisionSource(source),
+        };
+    }
+    isWebSocketVisionTransport() {
+        return this.webSocketVisionMode !== "off";
+    }
+    assertWebSocketVisionEnabled() {
+        if (this.webSocketVisionMode !== "enabled" ||
+            !this.webSocketVisionMessageSender) {
+            throw new Error("WebSocket vision input is disabled for this session");
+        }
+    }
+    normalizeWebSocketFps(fps) {
+        if (!Number.isFinite(fps) || fps <= 0)
+            return 1;
+        return Math.max(0.2, Math.min(10, fps));
+    }
+    sendWebSocketVisionSourceState(active, source) {
+        if (!this.webSocketVisionMessageSender)
+            return;
+        this.webSocketVisionMessageSender("vision-source-state", {
+            active,
+            source_label: this.toBackendVisionSourceLabel(source),
+        });
+    }
+    toBackendVisionSourceLabel(source) {
+        if (source === "webcam" || source === "camera")
+            return "webcam";
+        if (source === "canvas")
+            return "canvas";
+        if (source === "screen" || source === "screen_share")
+            return "screen";
+        return "custom";
+    }
+    toLiveKitSource(source) {
+        if (source === "screen" || source === "screen_share") {
+            return Track.Source.ScreenShare;
+        }
+        if (source === "unknown")
+            return Track.Source.Unknown;
+        // P1 backend sampling listens on the video channel. Keep webcam/canvas/custom
+        // as camera-compatible LiveKit video tracks while preserving semantic labels
+        // in SDK state and track names.
+        return Track.Source.Camera;
+    }
+    getLiveVisionSource() {
+        const source = this._activeVisionSource;
+        if (!source)
+            return null;
+        return source.track.readyState === "live" ? source : null;
+    }
+    makeVisionSourceState(reason) {
+        const source = this.getLiveVisionSource();
+        const stateReason = reason ??
+            (this.webSocketVisionMode === "disabled"
+                ? "websocket_vision_disabled"
+                : undefined);
+        return {
+            active: !!source,
+            source: source?.source ?? null,
+            sourceName: source?.sourceName ?? null,
+            trackState: source?.track.readyState ?? null,
+            transport: source?.transport ??
+                (this.isWebSocketVisionTransport() ? "websocket" : undefined),
+            ...(stateReason ? { reason: stateReason } : {}),
+        };
+    }
+    emitVideoStateChange(reason, extra = {}) {
+        this.emit("videoStateChange", {
+            isVideoEnabled: this._isVideoEnabled,
+            isVideoHidden: this._isVideoHidden,
+            activeVisionSource: this.activeVisionSource,
+            hasActiveVisionSource: this.hasActiveVisionSource,
+            visionSourceState: this.makeVisionSourceState(reason),
+            ...extra,
+        });
+    }
+    setActiveVisionSource(handle) {
+        if (this._activeVisionSource?.track !== handle.track) {
+            this._activeVisionSource?.cleanup?.();
+        }
+        this._activeVisionSource = handle;
+    }
+    async replaceActiveVisionSource(next) {
+        const current = this._activeVisionSource;
+        if (!current)
+            return;
+        if (next.track && current.track === next.track)
+            return;
+        if (shouldKeepExistingVisionSource(current.source, next.source, next.track !== undefined)) {
+            return;
+        }
+        await current.unpublish();
+    }
+    createPublicationHandle(publication, source, sourceName, stopTrackOnUnpublish) {
+        const track = this.mediaTrackFromPublication(publication);
+        if (!track)
+            return null;
+        let handle;
+        handle = {
+            track,
+            publication,
+            transport: "livekit",
+            sourceName,
+            source,
+            stopTrackOnUnpublish,
+            unpublish: async () => {
+                if (isWebcamVisionSource(source)) {
+                    await this.disableVideo();
+                    return;
+                }
+                await this.unpublishVisionSource(handle);
+            },
+        };
+        this.addTrackEndedListener(handle);
+        return handle;
+    }
+    addTrackEndedListener(handle) {
+        const previousCleanup = handle.cleanup;
+        const onEnded = () => this.clearEndedVisionSource(handle);
+        handle.track.addEventListener?.("ended", onEnded, { once: true });
+        handle.cleanup = () => {
+            handle.track.removeEventListener?.("ended", onEnded);
+            previousCleanup?.();
+        };
+    }
+    clearEndedVisionSource(handle) {
+        if (this._activeVisionSource?.track !== handle.track)
+            return;
+        handle.cleanup?.();
+        this._activeVisionSource = null;
+        if (handle.transport === "websocket") {
+            this.sendWebSocketVisionSourceState(false, handle.source);
+            if (isWebcamVisionSource(handle.source)) {
+                this._isVideoEnabled = false;
+            }
+            this.emitVideoStateChange("track_ended");
+            return;
+        }
+        this.updateState();
+        this.emitVideoStateChange("track_ended");
+    }
+    clearActiveVisionSourceForPublication(publication, reason) {
+        const current = this._activeVisionSource;
+        if (!current)
+            return;
+        if (current.publication !== publication &&
+            current.track !== this.mediaTrackFromPublication(publication)) {
+            return;
+        }
+        current.cleanup?.();
+        this._activeVisionSource = null;
+        this.emitVideoStateChange(reason);
+    }
+    mediaTrackFromPublication(publication) {
+        const track = publication?.track;
+        const mediaTrack = track?.mediaStreamTrack ?? track;
+        if (mediaTrack && typeof mediaTrack.readyState === "string") {
+            return mediaTrack;
+        }
+        return null;
+    }
+    semanticSourceForPublication(publication) {
+        const track = this.mediaTrackFromPublication(publication);
+        if (!track)
+            return undefined;
+        if (this._activeVisionSource?.track === track) {
+            return this._activeVisionSource.source;
+        }
+        return this.pendingVisionSourceTracks.get(track);
+    }
+    isWebcamPublication(publication) {
+        const semanticSource = this.semanticSourceForPublication(publication);
+        if (semanticSource !== undefined) {
+            return isWebcamVisionSource(semanticSource);
+        }
+        return this.isCameraLikeSource(publication?.source);
+    }
+    isCameraLikeSource(source) {
+        return source === "camera" || source === Track.Source.Camera;
+    }
     /**
      * Reset state on disconnect
      */
     reset() {
         this._isVideoEnabled = false;
         this._isVideoHidden = false;
-        this.emit('videoStateChange', {
+        this.webSocketVisionMessageSender = null;
+        this.webSocketVisionMode = "off";
+        const activeSource = this._activeVisionSource;
+        activeSource?.cleanup?.();
+        if (activeSource?.stopTrackOnUnpublish &&
+            activeSource.track.readyState !== "ended") {
+            activeSource.track.stop();
+        }
+        this._activeVisionSource = null;
+        this.emit("videoStateChange", {
             isVideoEnabled: false,
-            isVideoHidden: false
+            isVideoHidden: false,
+            activeVisionSource: null,
+            hasActiveVisionSource: false,
+            visionSourceState: this.makeVisionSourceState("reset"),
         });
     }
 }