@blueharford/scrypted-spatial-awareness 0.6.30 → 0.6.32

package/out/main.nodejs.js

@@ -34457,6 +34457,12 @@ class AlertManager {
         const notifierIds = rule.notifiers.length > 0
             ? rule.notifiers
             : this.getDefaultNotifiers();
+        // Debug: log which notifiers we're using
+        this.console.log(`[Notification] Rule ${rule.id} has ${rule.notifiers.length} notifiers, using ${notifierIds.length} notifier(s): ${notifierIds.join(', ') || 'NONE'}`);
+        if (notifierIds.length === 0) {
+            this.console.warn(`[Notification] No notifiers configured! Configure a notifier in plugin settings.`);
+            return;
+        }
         // Try to get a thumbnail from the camera
         let mediaObject;
         const cameraId = alert.details.toCameraId || alert.details.cameraId;
@@ -34551,27 +34557,34 @@ class AlertManager {
         try {
             // Try new multiple notifiers setting first
             const notifiers = this.storage.getItem('defaultNotifiers');
+            this.console.log(`[Notifiers] Raw storage value: ${notifiers}`);
             if (notifiers) {
                 // Could be JSON array or comma-separated string
                 try {
                     const parsed = JSON.parse(notifiers);
                     if (Array.isArray(parsed)) {
+                        this.console.log(`[Notifiers] Parsed JSON array: ${parsed.join(', ')}`);
                         return parsed;
                     }
                 }
                 catch {
                     // Not JSON, might be comma-separated or single value
                     if (notifiers.includes(',')) {
-                        return notifiers.split(',').map(s => s.trim()).filter(Boolean);
+                        const result = notifiers.split(',').map(s => s.trim()).filter(Boolean);
+                        this.console.log(`[Notifiers] Parsed comma-separated: ${result.join(', ')}`);
+                        return result;
                     }
+                    this.console.log(`[Notifiers] Single value: ${notifiers}`);
                     return [notifiers];
                 }
             }
             // Fallback to old single notifier setting
             const defaultNotifier = this.storage.getItem('defaultNotifier');
+            this.console.log(`[Notifiers] Fallback single notifier: ${defaultNotifier || 'NONE'}`);
             return defaultNotifier ? [defaultNotifier] : [];
         }
-        catch {
+        catch (e) {
+            this.console.error(`[Notifiers] Error reading notifiers:`, e);
             return [];
         }
     }
@@ -35427,7 +35440,7 @@ class SpatialReasoningEngine {
                             id: deviceId,
                             name: device.name || deviceId,
                             providerType: providerTypeEnum,
-                            lastUsed: 0,
+                            lastUsed: Date.now() - 60000, // Initialize to 1 minute ago so all LLMs start equal
                             errorCount: 0,
                         });
                         this.console.log(`[LLM] Using configured LLM: ${device.name}`);
@@ -35455,7 +35468,7 @@ class SpatialReasoningEngine {
                         id,
                         name: device.name || id,
                         providerType: providerTypeEnum,
-                        lastUsed: 0,
+                        lastUsed: Date.now() - 60000, // Initialize to 1 minute ago so all LLMs start equal
                         errorCount: 0,
                     });
                     this.console.log(`[LLM] Auto-discovered: ${device.name}`);
@@ -37489,14 +37502,22 @@ class TrackingEngine {
         this.lastLlmCallTime = Date.now();
     }
     /** Check and record LLM call - returns false if rate limited */
-    tryLlmCall() {
+    tryLlmCall(silent = false) {
         if (!this.isLlmCallAllowed()) {
-            this.console.log('[LLM] Rate limited, skipping LLM call');
+            // Only log once per rate limit window, not every call
+            if (!silent && !this.rateLimitLogged) {
+                const remaining = Math.ceil((this.config.llmDebounceInterval || 30000) - (Date.now() - this.lastLlmCallTime)) / 1000;
+                this.console.log(`[LLM] Rate limited, ${remaining.toFixed(0)}s until next call allowed`);
+                this.rateLimitLogged = true;
+            }
             return false;
         }
+        this.rateLimitLogged = false;
         this.recordLlmCall();
         return true;
     }
+    /** Track if we've already logged rate limit message */
+    rateLimitLogged = false;
     /** Get spatial reasoning result for movement (uses RAG + LLM) with debouncing and fallback */
     async getSpatialDescription(tracked, fromCameraId, toCameraId, transitTime, currentCameraId) {
         const fallbackEnabled = this.config.llmFallbackEnabled ?? true;
@@ -37706,31 +37727,31 @@ class TrackingEngine {
     }
     /** Capture and cache a snapshot for a tracked object, and start LLM analysis immediately */
     async captureAndCacheSnapshot(globalId, cameraId, eventType = 'entry') {
+        // Skip if we already have a recent snapshot for this object (within 5 seconds)
+        const existingSnapshot = this.snapshotCache.get(globalId);
+        if (existingSnapshot && eventType !== 'exit') {
+            // For entry/movement, we can reuse existing snapshot
+            // For exit, we want a fresh snapshot while they're still visible
+            return;
+        }
         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}`);
                     // Start LLM analysis immediately in parallel (don't await) - but respect rate limits
                     const tracked = this.state.getObject(globalId);
                     if (tracked && this.config.useLlmDescriptions && this.tryLlmCall()) {
-                        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 => {
+                        // Log when complete (but don't spam logs)
+                        descriptionPromise.catch(e => {
                             this.console.warn(`[LLM Prefetch] Failed for ${globalId.slice(0, 8)}: ${e}`);
                         });
                     }
-                    else if (tracked && this.config.useLlmDescriptions) {
-                        this.console.log(`[LLM Prefetch] Skipped for ${globalId.slice(0, 8)} - rate limited`);
-                    }
                 }
             }
         }
@@ -39360,7 +39381,7 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
         llmDebounceInterval: {
             title: 'LLM Rate Limit (seconds)',
             type: 'number',
-            defaultValue: 30,
+            defaultValue: 5,
             description: 'Minimum time between LLM calls to prevent API rate limiting. Increase if you get rate limit errors. (0 = no limit)',
             group: 'AI & Spatial Reasoning',
         },