@blueharford/scrypted-spatial-awareness 0.6.30 → 0.6.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blueharford/scrypted-spatial-awareness",
-  "version": "0.6.30",
+  "version": "0.6.32",
   "description": "Cross-camera object tracking for Scrypted NVR with spatial awareness",
   "author": "Joshua Seidel <blueharford>",
   "license": "Apache-2.0",

package/src/alerts/alert-manager.ts

@@ -110,6 +110,14 @@ export class AlertManager {
       ? 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: MediaObject | undefined;
     const cameraId = alert.details.toCameraId || alert.details.cameraId;
@@ -212,25 +220,33 @@ export 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 [];
     }
   }

package/src/core/spatial-reasoning.ts

@@ -466,7 +466,7 @@ export 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}`);
@@ -496,7 +496,7 @@ export 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,
           });
 

package/src/core/tracking-engine.ts

@@ -328,15 +328,24 @@ export class TrackingEngine {
   }
 
   /** Check and record LLM call - returns false if rate limited */
-  private tryLlmCall(): boolean {
+  private tryLlmCall(silent: boolean = false): boolean {
     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 */
+  private rateLimitLogged: boolean = false;
+
   /** Get spatial reasoning result for movement (uses RAG + LLM) with debouncing and fallback */
   private async getSpatialDescription(
     tracked: TrackedObject,
@@ -620,32 +629,34 @@ export class TrackingEngine {
     cameraId: string,
     eventType: 'entry' | 'exit' | 'movement' = 'entry'
   ): Promise<void> {
+    // 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<Camera>(cameraId);
       if (camera?.interfaces?.includes(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`);
           }
         }
       }

package/src/main.ts

@@ -130,7 +130,7 @@ export class SpatialAwarenessPlugin extends 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',
     },