@blueharford/scrypted-spatial-awareness 0.6.27 → 0.6.28

package/package.json

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

package/src/core/spatial-reasoning.ts

@@ -33,8 +33,8 @@ const { systemManager, mediaManager } = sdk;
 export interface SpatialReasoningConfig {
   /** Enable LLM-based descriptions */
   enableLlm: boolean;
-  /** Specific LLM device ID to use (if not set, auto-discovers) */
-  llmDeviceId?: string;
+  /** Specific LLM device IDs to use (if not set, auto-discovers all) */
+  llmDeviceIds?: string[];
   /** Enable landmark learning/suggestions */
   enableLandmarkLearning: boolean;
   /** Minimum confidence for landmark suggestions */
@@ -449,30 +449,38 @@ export class SpatialReasoningEngine {
   }> = [];
   private llmIndex: number = 0;
 
-  /** Find LLM devices - uses configured device or auto-discovers all for load balancing */
+  /** Find LLM devices - uses configured devices or auto-discovers all for load balancing */
   private async findAllLlmDevices(): Promise<void> {
     if (this.llmSearched) return;
     this.llmSearched = true;
 
     try {
-      // If a specific LLM device is configured, use only that one
-      if (this.config.llmDeviceId) {
-        const device = systemManager.getDeviceById(this.config.llmDeviceId);
-        if (device?.interfaces?.includes('ChatCompletion')) {
-          const providerTypeEnum = this.detectProviderType(device);
-          this.llmDevices.push({
-            device: device as unknown as ChatCompletionDevice,
-            id: this.config.llmDeviceId,
-            name: device.name || this.config.llmDeviceId,
-            providerType: providerTypeEnum,
-            lastUsed: 0,
-            errorCount: 0,
-          });
-          this.console.log(`[LLM] Using configured LLM: ${device.name}`);
+      // If specific LLM devices are configured, use only those
+      if (this.config.llmDeviceIds && this.config.llmDeviceIds.length > 0) {
+        for (const deviceId of this.config.llmDeviceIds) {
+          const device = systemManager.getDeviceById(deviceId);
+          if (device?.interfaces?.includes('ChatCompletion')) {
+            const providerTypeEnum = this.detectProviderType(device);
+            this.llmDevices.push({
+              device: device as unknown as ChatCompletionDevice,
+              id: deviceId,
+              name: device.name || deviceId,
+              providerType: providerTypeEnum,
+              lastUsed: 0,
+              errorCount: 0,
+            });
+            this.console.log(`[LLM] Using configured LLM: ${device.name}`);
+          } else {
+            this.console.warn(`[LLM] Configured device ${deviceId} not found or doesn't support ChatCompletion`);
+          }
+        }
+
+        if (this.llmDevices.length > 0) {
+          this.console.log(`[LLM] Using ${this.llmDevices.length} configured LLM provider(s)`);
           return;
-        } else {
-          this.console.warn(`[LLM] Configured device ${this.config.llmDeviceId} not found or doesn't support ChatCompletion`);
         }
+        // Fall through to auto-discovery if none of the configured devices worked
+        this.console.warn('[LLM] No configured devices available, falling back to auto-discovery');
       }
 
       // Auto-discover all LLM devices for load balancing
@@ -492,7 +500,7 @@ export class SpatialReasoningEngine {
             errorCount: 0,
           });
 
-          this.console.log(`[LLM] Found: ${device.name}`);
+          this.console.log(`[LLM] Auto-discovered: ${device.name}`);
         }
       }
 

package/src/core/tracking-engine.ts

@@ -63,8 +63,8 @@ export interface TrackingEngineConfig {
   objectAlertCooldown: number;
   /** Use LLM for enhanced descriptions */
   useLlmDescriptions: boolean;
-  /** Specific LLM device ID to use (if not set, auto-discovers all for load balancing) */
-  llmDeviceId?: string;
+  /** Specific LLM device IDs to use (if not set, auto-discovers all for load balancing) */
+  llmDeviceIds?: string[];
   /** LLM rate limit interval (ms) - minimum time between LLM calls */
   llmDebounceInterval?: number;
   /** Whether to fall back to basic notifications when LLM is unavailable or slow */
@@ -163,7 +163,7 @@ export class TrackingEngine {
     // Initialize spatial reasoning engine
     const spatialConfig: SpatialReasoningConfig = {
       enableLlm: config.useLlmDescriptions,
-      llmDeviceId: config.llmDeviceId,
+      llmDeviceIds: config.llmDeviceIds,
       enableLandmarkLearning: config.enableLandmarkLearning ?? true,
       landmarkConfidenceThreshold: config.landmarkConfidenceThreshold ?? 0.7,
       contextCacheTtl: 60000, // 1 minute cache

package/src/main.ts

@@ -238,11 +238,12 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
     },
 
     // Integrations
-    llmDevice: {
-      title: 'LLM Provider',
+    llmDevices: {
+      title: 'LLM Providers',
       type: 'device',
+      multiple: true,
       deviceFilter: `interfaces.includes('ChatCompletion')`,
-      description: 'Select the LLM plugin to use for smart descriptions (e.g., OpenAI, Anthropic, Ollama)',
+      description: 'Select one or more LLM providers for smart descriptions. Multiple providers will be load-balanced.',
       group: 'Integrations',
     },
     defaultNotifiers: {
@@ -362,7 +363,7 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
       loiteringThreshold: (this.storageSettings.values.loiteringThreshold as number || 3) * 1000,
       objectAlertCooldown: (this.storageSettings.values.objectAlertCooldown as number || 30) * 1000,
       useLlmDescriptions: this.storageSettings.values.useLlmDescriptions as boolean ?? true,
-      llmDeviceId: this.storageSettings.values.llmDevice as string || undefined,
+      llmDeviceIds: this.parseLlmDevices(),
       llmDebounceInterval: (this.storageSettings.values.llmDebounceInterval as number || 30) * 1000,
       llmFallbackEnabled: this.storageSettings.values.llmFallbackEnabled as boolean ?? true,
       llmFallbackTimeout: (this.storageSettings.values.llmFallbackTimeout as number || 3) * 1000,
@@ -417,6 +418,36 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
     }
   }
 
+  /** Parse LLM devices from settings - handles both array and single value formats */
+  private parseLlmDevices(): string[] | undefined {
+    const value = this.storageSettings.values.llmDevices;
+    if (!value) return undefined;
+
+    // Handle array format
+    if (Array.isArray(value)) {
+      const filtered = value.filter(Boolean);
+      return filtered.length > 0 ? filtered : undefined;
+    }
+
+    // Handle JSON string format
+    if (typeof value === 'string') {
+      try {
+        const parsed = JSON.parse(value);
+        if (Array.isArray(parsed)) {
+          const filtered = parsed.filter(Boolean);
+          return filtered.length > 0 ? filtered : undefined;
+        }
+        // Single device ID string
+        return value ? [value] : undefined;
+      } catch {
+        // Not JSON, treat as single device ID
+        return value ? [value] : undefined;
+      }
+    }
+
+    return undefined;
+  }
+
   // ==================== DeviceProvider Implementation ====================
 
   async getDevice(nativeId: string): Promise<any> {
@@ -723,7 +754,7 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
       key === 'llmDebounceInterval' ||
       key === 'llmFallbackEnabled' ||
       key === 'llmFallbackTimeout' ||
-      key === 'llmDevice' ||
+      key === 'llmDevices' ||
       key === 'enableTransitTimeLearning' ||
       key === 'enableConnectionSuggestions' ||
       key === 'enableLandmarkLearning' ||