@blueharford/scrypted-spatial-awareness 0.6.12 → 0.6.13

package/out/main.nodejs.js

@@ -36943,6 +36943,9 @@ class TrackingEngine {
     trainingConfig = training_1.DEFAULT_TRAINING_CONFIG;
     /** Callback for training status updates */
     onTrainingStatusUpdate;
+    // ==================== Snapshot Cache ====================
+    /** Cached snapshots for tracked objects (for faster notifications) */
+    snapshotCache = new Map();
     constructor(topology, state, alertManager, config, console) {
         this.topology = topology;
         this.state = state;
@@ -37166,6 +37169,12 @@ class TrackingEngine {
             const lastSighting = (0, tracked_object_1.getLastSighting)(tracked);
             if (lastSighting && lastSighting.cameraId !== sighting.cameraId) {
                 const transitDuration = sighting.timestamp - lastSighting.timestamp;
+                // Update cached snapshot from new camera (object is now visible here)
+                if (this.config.useLlmDescriptions) {
+                    this.captureAndCacheSnapshot(tracked.globalId, sighting.cameraId).catch(e => {
+                        this.console.warn(`[Transition Snapshot] Failed to update snapshot: ${e}`);
+                    });
+                }
                 // Add journey segment
                 this.state.addJourney(tracked.globalId, {
                     fromCameraId: lastSighting.cameraId,
@@ -37232,6 +37241,13 @@ class TrackingEngine {
     }
     /** Schedule an alert after loitering threshold passes */
     scheduleLoiteringAlert(globalId, sighting, isEntryPoint) {
+        // Capture snapshot IMMEDIATELY when object is first detected (don't wait for loitering threshold)
+        // This ensures we have a good image while the person/object is still in frame
+        if (this.config.useLlmDescriptions) {
+            this.captureAndCacheSnapshot(globalId, sighting.cameraId).catch(e => {
+                this.console.warn(`[Snapshot] Failed to cache initial snapshot: ${e}`);
+            });
+        }
         // Check after loitering threshold if object is still being tracked
         setTimeout(async () => {
             const tracked = this.state.getObject(globalId);
@@ -37240,22 +37256,9 @@ class TrackingEngine {
             // Check if we've already alerted for this object
             if (this.isInAlertCooldown(globalId))
                 return;
-            // Get snapshot for LLM description (if LLM is enabled)
-            let mediaObject;
-            this.console.log(`[Entry Alert] useLlmDescriptions=${this.config.useLlmDescriptions}`);
-            if (this.config.useLlmDescriptions) {
-                try {
-                    const camera = systemManager.getDeviceById(sighting.cameraId);
-                    this.console.log(`[Entry Alert] Camera ${sighting.cameraId} has Camera interface: ${camera?.interfaces?.includes(sdk_1.ScryptedInterface.Camera)}`);
-                    if (camera?.interfaces?.includes(sdk_1.ScryptedInterface.Camera)) {
-                        mediaObject = await camera.takePicture();
-                        this.console.log(`[Entry Alert] Got snapshot: ${!!mediaObject}`);
-                    }
-                }
-                catch (e) {
-                    this.console.warn('[Entry Alert] Failed to get snapshot:', e);
-                }
-            }
+            // Use cached snapshot (captured when object was first detected)
+            let mediaObject = this.snapshotCache.get(globalId);
+            this.console.log(`[Entry Alert] Using cached snapshot: ${!!mediaObject}`);
             // Generate spatial description (now async with LLM support)
             this.console.log(`[Entry Alert] Calling generateEntryDescription with mediaObject=${!!mediaObject}`);
             const spatialResult = await this.spatialReasoning.generateEntryDescription(tracked, sighting.cameraId, mediaObject);
@@ -37290,6 +37293,22 @@ class TrackingEngine {
             this.recordAlertTime(globalId);
         }, this.config.loiteringThreshold);
     }
+    /** Capture and cache a snapshot for a tracked object */
+    async captureAndCacheSnapshot(globalId, cameraId) {
+        try {
+            const camera = systemManager.getDeviceById(cameraId);
+            if (camera?.interfaces?.includes(sdk_1.ScryptedInterface.Camera)) {
+                const mediaObject = await camera.takePicture();
+                if (mediaObject) {
+                    this.snapshotCache.set(globalId, mediaObject);
+                    this.console.log(`[Snapshot] Cached snapshot for ${globalId.slice(0, 8)} from ${cameraId}`);
+                }
+            }
+        }
+        catch (e) {
+            this.console.warn(`[Snapshot] Failed to capture snapshot: ${e}`);
+        }
+    }
     /** Attempt to correlate a sighting with existing tracked objects */
     async correlateDetection(sighting) {
         const activeObjects = this.state.getActiveObjects();
@@ -37329,27 +37348,20 @@ class TrackingEngine {
     handlePotentialExit(tracked, sighting) {
         // Mark as pending and set timer
         this.state.markPending(tracked.globalId);
+        // Capture a fresh snapshot now while object is still visible (before they leave)
+        if (this.config.useLlmDescriptions) {
+            this.captureAndCacheSnapshot(tracked.globalId, sighting.cameraId).catch(e => {
+                this.console.warn(`[Exit Snapshot] Failed to update snapshot: ${e}`);
+            });
+        }
         // Wait for correlation window before marking as exited
         const timer = setTimeout(async () => {
             const current = this.state.getObject(tracked.globalId);
             if (current && current.state === 'pending') {
                 this.state.markExited(tracked.globalId, sighting.cameraId, sighting.cameraName);
-                // Get snapshot for LLM description (if LLM is enabled)
-                let mediaObject;
-                this.console.log(`[Exit Alert] useLlmDescriptions=${this.config.useLlmDescriptions}`);
-                if (this.config.useLlmDescriptions) {
-                    try {
-                        const camera = systemManager.getDeviceById(sighting.cameraId);
-                        this.console.log(`[Exit Alert] Camera ${sighting.cameraId} has Camera interface: ${camera?.interfaces?.includes(sdk_1.ScryptedInterface.Camera)}`);
-                        if (camera?.interfaces?.includes(sdk_1.ScryptedInterface.Camera)) {
-                            mediaObject = await camera.takePicture();
-                            this.console.log(`[Exit Alert] Got snapshot: ${!!mediaObject}`);
-                        }
-                    }
-                    catch (e) {
-                        this.console.warn('[Exit Alert] Failed to get snapshot:', e);
-                    }
-                }
+                // Use cached snapshot (captured when exit was first detected, while object was still visible)
+                let mediaObject = this.snapshotCache.get(tracked.globalId);
+                this.console.log(`[Exit Alert] Using cached snapshot: ${!!mediaObject}`);
                 // Generate rich exit description using topology context (now async with LLM support)
                 this.console.log(`[Exit Alert] Calling generateExitDescription with mediaObject=${!!mediaObject}`);
                 const spatialResult = await this.spatialReasoning.generateExitDescription(current, sighting.cameraId, mediaObject);
@@ -37362,6 +37374,8 @@ class TrackingEngine {
                     involvedLandmarks: spatialResult.involvedLandmarks?.map(l => l.name),
                     usedLlm: spatialResult.usedLlm,
                 });
+                // Clean up cached snapshot after exit alert
+                this.snapshotCache.delete(tracked.globalId);
             }
             this.pendingTimers.delete(tracked.globalId);
         }, this.config.correlationWindow);
@@ -37377,6 +37391,8 @@ class TrackingEngine {
                 this.state.markLost(tracked.globalId);
                 this.console.log(`Object ${tracked.globalId.slice(0, 8)} marked as lost ` +
                     `(not seen for ${Math.round(timeSinceSeen / 1000)}s)`);
+                // Clean up cached snapshot
+                this.snapshotCache.delete(tracked.globalId);
                 this.alertManager.checkAndAlert('lost_tracking', tracked, {
                     objectClass: tracked.className,
                     objectLabel: tracked.label,