@blueharford/scrypted-spatial-awareness 0.6.13 → 0.6.14

package/out/main.nodejs.js

@@ -36946,6 +36946,8 @@ class TrackingEngine {
     // ==================== Snapshot Cache ====================
     /** Cached snapshots for tracked objects (for faster notifications) */
     snapshotCache = new Map();
+    /** Pending LLM description promises (started when snapshot is captured) */
+    pendingDescriptions = new Map();
     constructor(topology, state, alertManager, config, console) {
         this.topology = topology;
         this.state = state;
@@ -37256,13 +37258,28 @@ class TrackingEngine {
             // Check if we've already alerted for this object
             if (this.isInAlertCooldown(globalId))
                 return;
-            // 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);
-            this.console.log(`[Entry Alert] Got description: "${spatialResult.description.substring(0, 60)}...", usedLlm=${spatialResult.usedLlm}`);
+            // Use prefetched LLM result if available (started when snapshot was captured)
+            let spatialResult;
+            const pendingDescription = this.pendingDescriptions.get(globalId);
+            if (pendingDescription) {
+                this.console.log(`[Entry Alert] Using prefetched LLM result for ${globalId.slice(0, 8)}`);
+                try {
+                    spatialResult = await pendingDescription;
+                    this.console.log(`[Entry Alert] Prefetch result: "${spatialResult.description.substring(0, 60)}...", usedLlm=${spatialResult.usedLlm}`);
+                }
+                catch (e) {
+                    this.console.warn(`[Entry Alert] Prefetch failed, generating fallback: ${e}`);
+                    spatialResult = await this.spatialReasoning.generateEntryDescription(tracked, sighting.cameraId);
+                }
+                this.pendingDescriptions.delete(globalId);
+            }
+            else {
+                // Fallback: generate description now (slower path)
+                this.console.log(`[Entry Alert] No prefetch available, generating now`);
+                const mediaObject = this.snapshotCache.get(globalId);
+                spatialResult = await this.spatialReasoning.generateEntryDescription(tracked, sighting.cameraId, mediaObject);
+                this.console.log(`[Entry Alert] Got description: "${spatialResult.description.substring(0, 60)}...", usedLlm=${spatialResult.usedLlm}`);
+            }
             if (isEntryPoint) {
                 // Entry point - generate property entry alert
                 await this.alertManager.checkAndAlert('property_entry', tracked, {
@@ -37293,8 +37310,8 @@ class TrackingEngine {
             this.recordAlertTime(globalId);
         }, this.config.loiteringThreshold);
     }
-    /** Capture and cache a snapshot for a tracked object */
-    async captureAndCacheSnapshot(globalId, cameraId) {
+    /** Capture and cache a snapshot for a tracked object, and start LLM analysis immediately */
+    async captureAndCacheSnapshot(globalId, cameraId, eventType = 'entry') {
         try {
             const camera = systemManager.getDeviceById(cameraId);
             if (camera?.interfaces?.includes(sdk_1.ScryptedInterface.Camera)) {
@@ -37302,6 +37319,21 @@ class TrackingEngine {
                 if (mediaObject) {
                     this.snapshotCache.set(globalId, mediaObject);
                     this.console.log(`[Snapshot] Cached snapshot for ${globalId.slice(0, 8)} from ${cameraId}`);
+                    // Start LLM analysis immediately in parallel (don't await)
+                    const tracked = this.state.getObject(globalId);
+                    if (tracked && this.config.useLlmDescriptions) {
+                        this.console.log(`[LLM Prefetch] Starting ${eventType} analysis for ${globalId.slice(0, 8)}`);
+                        const descriptionPromise = eventType === 'exit'
+                            ? this.spatialReasoning.generateExitDescription(tracked, cameraId, mediaObject)
+                            : this.spatialReasoning.generateEntryDescription(tracked, cameraId, mediaObject);
+                        this.pendingDescriptions.set(globalId, descriptionPromise);
+                        // Log when complete (for debugging)
+                        descriptionPromise.then(result => {
+                            this.console.log(`[LLM Prefetch] ${eventType} analysis ready for ${globalId.slice(0, 8)}: "${result.description.substring(0, 40)}..."`);
+                        }).catch(e => {
+                            this.console.warn(`[LLM Prefetch] Failed for ${globalId.slice(0, 8)}: ${e}`);
+                        });
+                    }
                 }
             }
         }
@@ -37349,8 +37381,9 @@ class TrackingEngine {
         // Mark as pending and set timer
         this.state.markPending(tracked.globalId);
         // Capture a fresh snapshot now while object is still visible (before they leave)
+        // Also starts LLM analysis immediately in parallel
         if (this.config.useLlmDescriptions) {
-            this.captureAndCacheSnapshot(tracked.globalId, sighting.cameraId).catch(e => {
+            this.captureAndCacheSnapshot(tracked.globalId, sighting.cameraId, 'exit').catch(e => {
                 this.console.warn(`[Exit Snapshot] Failed to update snapshot: ${e}`);
             });
         }
@@ -37359,13 +37392,28 @@ class TrackingEngine {
             const current = this.state.getObject(tracked.globalId);
             if (current && current.state === 'pending') {
                 this.state.markExited(tracked.globalId, sighting.cameraId, sighting.cameraName);
-                // 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);
-                this.console.log(`[Exit Alert] Object ${tracked.globalId.slice(0, 8)} exited: "${spatialResult.description.substring(0, 60)}...", usedLlm=${spatialResult.usedLlm}`);
+                // Use prefetched LLM result if available (started when exit was first detected)
+                let spatialResult;
+                const pendingDescription = this.pendingDescriptions.get(tracked.globalId);
+                if (pendingDescription) {
+                    this.console.log(`[Exit Alert] Using prefetched LLM result for ${tracked.globalId.slice(0, 8)}`);
+                    try {
+                        spatialResult = await pendingDescription;
+                        this.console.log(`[Exit Alert] Prefetch result: "${spatialResult.description.substring(0, 60)}...", usedLlm=${spatialResult.usedLlm}`);
+                    }
+                    catch (e) {
+                        this.console.warn(`[Exit Alert] Prefetch failed, generating fallback: ${e}`);
+                        spatialResult = await this.spatialReasoning.generateExitDescription(current, sighting.cameraId);
+                    }
+                    this.pendingDescriptions.delete(tracked.globalId);
+                }
+                else {
+                    // Fallback: generate description now (slower path)
+                    this.console.log(`[Exit Alert] No prefetch available, generating now`);
+                    const mediaObject = this.snapshotCache.get(tracked.globalId);
+                    spatialResult = await this.spatialReasoning.generateExitDescription(current, sighting.cameraId, mediaObject);
+                    this.console.log(`[Exit Alert] Got description: "${spatialResult.description.substring(0, 60)}...", usedLlm=${spatialResult.usedLlm}`);
+                }
                 await this.alertManager.checkAndAlert('property_exit', current, {
                     cameraId: sighting.cameraId,
                     cameraName: sighting.cameraName,
@@ -37374,8 +37422,9 @@ class TrackingEngine {
                     involvedLandmarks: spatialResult.involvedLandmarks?.map(l => l.name),
                     usedLlm: spatialResult.usedLlm,
                 });
-                // Clean up cached snapshot after exit alert
+                // Clean up cached snapshot and pending descriptions after exit alert
                 this.snapshotCache.delete(tracked.globalId);
+                this.pendingDescriptions.delete(tracked.globalId);
             }
             this.pendingTimers.delete(tracked.globalId);
         }, this.config.correlationWindow);
@@ -37391,8 +37440,9 @@ 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
+                // Clean up cached snapshot and pending descriptions
                 this.snapshotCache.delete(tracked.globalId);
+                this.pendingDescriptions.delete(tracked.globalId);
                 this.alertManager.checkAndAlert('lost_tracking', tracked, {
                     objectClass: tracked.className,
                     objectLabel: tracked.label,