@blueharford/scrypted-spatial-awareness 0.6.25 → 0.6.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blueharford/scrypted-spatial-awareness",
-  "version": "0.6.25",
+  "version": "0.6.27",
   "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,6 +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;
   /** Enable landmark learning/suggestions */
   enableLandmarkLearning: boolean;
   /** Minimum confidence for landmark suggestions */
@@ -436,69 +438,158 @@ export class SpatialReasoningEngine {
   private llmProvider: string | null = null;
   private llmProviderType: LlmProvider = 'unknown';
 
-  /** Find or initialize LLM device - looks for ChatCompletion interface from @scrypted/llm plugin */
-  private async findLlmDevice(): Promise<ChatCompletionDevice | null> {
-    if (this.llmDevice) return this.llmDevice;
-    if (this.llmSearched) return null; // Already searched and found nothing
-
+  // Load balancing for multiple LLMs
+  private llmDevices: Array<{
+    device: ChatCompletionDevice;
+    id: string;
+    name: string;
+    providerType: LlmProvider;
+    lastUsed: number;
+    errorCount: number;
+  }> = [];
+  private llmIndex: number = 0;
+
+  /** Find LLM devices - uses configured device or auto-discovers all for load balancing */
+  private async findAllLlmDevices(): Promise<void> {
+    if (this.llmSearched) return;
     this.llmSearched = true;
 
     try {
-      // Look for devices with ChatCompletion interface (the correct interface for @scrypted/llm)
+      // 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}`);
+          return;
+        } else {
+          this.console.warn(`[LLM] Configured device ${this.config.llmDeviceId} not found or doesn't support ChatCompletion`);
+        }
+      }
+
+      // Auto-discover all LLM devices for load balancing
       for (const id of Object.keys(systemManager.getSystemState())) {
         const device = systemManager.getDeviceById(id);
         if (!device) continue;
 
-        // Check if this device has ChatCompletion interface
-        // The @scrypted/llm plugin exposes ChatCompletion, not ObjectDetection
         if (device.interfaces?.includes('ChatCompletion')) {
-          const deviceName = device.name?.toLowerCase() || '';
-          const pluginId = (device as any).pluginId?.toLowerCase() || '';
-
-          // Identify the provider type for logging and image format selection
-          let providerType = 'Unknown';
-          let providerTypeEnum: LlmProvider = 'unknown';
-
-          if (deviceName.includes('openai') || deviceName.includes('gpt')) {
-            providerType = 'OpenAI';
-            providerTypeEnum = 'openai';
-          } else if (deviceName.includes('anthropic') || deviceName.includes('claude')) {
-            providerType = 'Anthropic';
-            providerTypeEnum = 'anthropic';
-          } else if (deviceName.includes('ollama')) {
-            providerType = 'Ollama';
-            providerTypeEnum = 'openai'; // Ollama uses OpenAI-compatible format
-          } else if (deviceName.includes('gemini') || deviceName.includes('google')) {
-            providerType = 'Google';
-            providerTypeEnum = 'openai'; // Google uses OpenAI-compatible format
-          } else if (deviceName.includes('llama')) {
-            providerType = 'llama.cpp';
-            providerTypeEnum = 'openai'; // llama.cpp uses OpenAI-compatible format
-          } else if (pluginId.includes('@scrypted/llm') || pluginId.includes('llm')) {
-            providerType = 'Scrypted LLM';
-            providerTypeEnum = 'unknown';
-          }
+          const providerTypeEnum = this.detectProviderType(device);
+
+          this.llmDevices.push({
+            device: device as unknown as ChatCompletionDevice,
+            id,
+            name: device.name || id,
+            providerType: providerTypeEnum,
+            lastUsed: 0,
+            errorCount: 0,
+          });
 
-          this.llmDevice = device as unknown as ChatCompletionDevice;
-          this.llmProvider = `${providerType} (${device.name})`;
-          this.llmProviderType = providerTypeEnum;
-          this.console.log(`[LLM] Connected to ${providerType}: ${device.name}`);
-          this.console.log(`[LLM] Plugin: ${pluginId || 'N/A'}`);
-          this.console.log(`[LLM] Image format: ${providerTypeEnum}`);
-          this.console.log(`[LLM] Interfaces: ${device.interfaces?.join(', ')}`);
-          return this.llmDevice;
+          this.console.log(`[LLM] Found: ${device.name}`);
         }
       }
 
-      // If we get here, no LLM plugin found
-      this.console.warn('[LLM] No ChatCompletion device found. Install @scrypted/llm for enhanced descriptions.');
-      this.console.warn('[LLM] Falling back to rule-based descriptions using topology data.');
-
+      if (this.llmDevices.length === 0) {
+        this.console.warn('[LLM] No ChatCompletion devices found. Install @scrypted/llm for enhanced descriptions.');
+      } else {
+        this.console.log(`[LLM] Load balancing across ${this.llmDevices.length} LLM device(s)`);
+      }
     } catch (e) {
-      this.console.error('[LLM] Error searching for LLM device:', e);
+      this.console.error('[LLM] Error searching for LLM devices:', e);
     }
+  }
 
-    return null;
+  /** Detect the provider type from device name */
+  private detectProviderType(device: ScryptedDevice): LlmProvider {
+    const deviceName = device.name?.toLowerCase() || '';
+    const pluginId = (device as any).pluginId?.toLowerCase() || '';
+
+    if (deviceName.includes('openai') || deviceName.includes('gpt')) {
+      return 'openai';
+    } else if (deviceName.includes('anthropic') || deviceName.includes('claude')) {
+      return 'anthropic';
+    } else if (deviceName.includes('ollama')) {
+      return 'openai'; // Ollama uses OpenAI-compatible format
+    } else if (deviceName.includes('gemini') || deviceName.includes('google')) {
+      return 'openai'; // Google uses OpenAI-compatible format
+    } else if (deviceName.includes('llama')) {
+      return 'openai'; // llama.cpp uses OpenAI-compatible format
+    } else if (pluginId.includes('@scrypted/llm') || pluginId.includes('llm')) {
+      return 'unknown';
+    }
+    return 'unknown';
+  }
+
+  /** Get the next available LLM using round-robin with least-recently-used preference */
+  private async findLlmDevice(): Promise<ChatCompletionDevice | null> {
+    await this.findAllLlmDevices();
+
+    if (this.llmDevices.length === 0) return null;
+
+    // If only one LLM, just use it
+    if (this.llmDevices.length === 1) {
+      const llm = this.llmDevices[0];
+      this.llmDevice = llm.device;
+      this.llmProvider = llm.name;
+      this.llmProviderType = llm.providerType;
+      return llm.device;
+    }
+
+    // Find the LLM with the oldest lastUsed time (least recently used)
+    // Also prefer LLMs with fewer errors
+    let bestIndex = 0;
+    let bestScore = Infinity;
+
+    for (let i = 0; i < this.llmDevices.length; i++) {
+      const llm = this.llmDevices[i];
+      // Score = lastUsed time + (errorCount * 60 seconds penalty)
+      const score = llm.lastUsed + (llm.errorCount * 60000);
+      if (score < bestScore) {
+        bestScore = score;
+        bestIndex = i;
+      }
+    }
+
+    const selected = this.llmDevices[bestIndex];
+    this.llmDevice = selected.device;
+    this.llmProvider = selected.name;
+    this.llmProviderType = selected.providerType;
+
+    this.console.log(`[LLM] Selected: ${selected.name} (last used ${Math.round((Date.now() - selected.lastUsed) / 1000)}s ago, errors: ${selected.errorCount})`);
+
+    return selected.device;
+  }
+
+  /** Mark an LLM as used (for load balancing) */
+  private markLlmUsed(device: ChatCompletionDevice): void {
+    const llm = this.llmDevices.find(l => l.device === device);
+    if (llm) {
+      llm.lastUsed = Date.now();
+    }
+  }
+
+  /** Mark an LLM as having an error (for load balancing - will be deprioritized) */
+  private markLlmError(device: ChatCompletionDevice): void {
+    const llm = this.llmDevices.find(l => l.device === device);
+    if (llm) {
+      llm.errorCount++;
+      this.console.log(`[LLM] ${llm.name} error count: ${llm.errorCount}`);
+    }
+  }
+
+  /** Reset error count for an LLM after successful call */
+  private markLlmSuccess(device: ChatCompletionDevice): void {
+    const llm = this.llmDevices.find(l => l.device === device);
+    if (llm && llm.errorCount > 0) {
+      llm.errorCount = Math.max(0, llm.errorCount - 1); // Gradually reduce error count
+    }
   }
 
   /** Get the current LLM provider name */
@@ -946,6 +1037,9 @@ export class SpatialReasoningEngine {
         messageContent = prompt;
       }
 
+      // Mark LLM as used for load balancing
+      this.markLlmUsed(llm);
+
       // Call LLM using ChatCompletion interface
       const result = await llm.getChatCompletion({
         messages: [
@@ -961,12 +1055,14 @@ export class SpatialReasoningEngine {
       // Extract description from ChatCompletion result
       const content = result?.choices?.[0]?.message?.content;
       if (content && typeof content === 'string') {
+        this.markLlmSuccess(llm);
         return content.trim();
       }
 
       return null;
     } catch (e) {
       this.console.warn('LLM description generation failed:', e);
+      this.markLlmError(llm);
       return null;
     }
   }
@@ -1049,6 +1145,9 @@ Examples of good descriptions:
 
 Generate ONLY the description, nothing else:`;
 
+      // Mark LLM as used for load balancing
+      this.markLlmUsed(llm);
+
       // Try multimodal format first, fall back to text-only if it fails
       let result: any;
       let usedVision = false;
@@ -1101,6 +1200,7 @@ Generate ONLY the description, nothing else:`;
       const content = result?.choices?.[0]?.message?.content;
       if (content && typeof content === 'string') {
         this.console.log(`[LLM] Got ${eventType} description (vision=${usedVision}): ${content.trim().substring(0, 50)}...`);
+        this.markLlmSuccess(llm);
         return content.trim();
       }
 
@@ -1108,6 +1208,7 @@ Generate ONLY the description, nothing else:`;
       return null;
     } catch (e) {
       this.console.warn(`[LLM] ${eventType} description generation failed:`, e);
+      this.markLlmError(llm);
       return null;
     }
   }

package/src/core/topology-discovery.ts

@@ -254,11 +254,19 @@ export class TopologyDiscoveryEngine {
     return this.config.discoveryIntervalHours > 0;
   }
 
-  /** Find LLM device with ChatCompletion interface */
-  private async findLlmDevice(): Promise<ChatCompletionDevice | null> {
-    if (this.llmDevice) return this.llmDevice;
-    if (this.llmSearched) return null;
-
+  // Load balancing for multiple LLMs
+  private llmDevices: Array<{
+    device: ChatCompletionDevice;
+    id: string;
+    name: string;
+    providerType: LlmProvider;
+    lastUsed: number;
+    errorCount: number;
+  }> = [];
+
+  /** Find ALL LLM devices for load balancing */
+  private async findAllLlmDevices(): Promise<void> {
+    if (this.llmSearched) return;
     this.llmSearched = true;
 
     try {
@@ -269,32 +277,84 @@ export class TopologyDiscoveryEngine {
         if (device.interfaces?.includes('ChatCompletion')) {
           const deviceName = device.name?.toLowerCase() || '';
 
-          // Detect provider type for image format selection
+          let providerType: LlmProvider = 'unknown';
           if (deviceName.includes('openai') || deviceName.includes('gpt')) {
-            this.llmProviderType = 'openai';
+            providerType = 'openai';
           } else if (deviceName.includes('anthropic') || deviceName.includes('claude')) {
-            this.llmProviderType = 'anthropic';
+            providerType = 'anthropic';
           } else if (deviceName.includes('ollama') || deviceName.includes('gemini') ||
                      deviceName.includes('google') || deviceName.includes('llama')) {
-            // These providers use OpenAI-compatible format
-            this.llmProviderType = 'openai';
-          } else {
-            this.llmProviderType = 'unknown';
+            providerType = 'openai';
           }
 
-          this.llmDevice = device as unknown as ChatCompletionDevice;
-          this.console.log(`[Discovery] Connected to LLM: ${device.name}`);
-          this.console.log(`[Discovery] Image format: ${this.llmProviderType}`);
-          return this.llmDevice;
+          this.llmDevices.push({
+            device: device as unknown as ChatCompletionDevice,
+            id,
+            name: device.name || id,
+            providerType,
+            lastUsed: 0,
+            errorCount: 0,
+          });
+
+          this.console.log(`[Discovery] Found LLM: ${device.name}`);
         }
       }
 
-      this.console.warn('[Discovery] No ChatCompletion device found. Vision-based discovery unavailable.');
+      if (this.llmDevices.length === 0) {
+        this.console.warn('[Discovery] No ChatCompletion devices found. Vision-based discovery unavailable.');
+      } else {
+        this.console.log(`[Discovery] Load balancing across ${this.llmDevices.length} LLM device(s)`);
+      }
     } catch (e) {
-      this.console.error('[Discovery] Error finding LLM device:', e);
+      this.console.error('[Discovery] Error finding LLM devices:', e);
+    }
+  }
+
+  /** Find LLM device with ChatCompletion interface - uses load balancing */
+  private async findLlmDevice(): Promise<ChatCompletionDevice | null> {
+    await this.findAllLlmDevices();
+
+    if (this.llmDevices.length === 0) return null;
+
+    // If only one LLM, just use it
+    if (this.llmDevices.length === 1) {
+      const llm = this.llmDevices[0];
+      this.llmDevice = llm.device;
+      this.llmProviderType = llm.providerType;
+      return llm.device;
     }
 
-    return null;
+    // Find the LLM with oldest lastUsed time (least recently used)
+    let bestIndex = 0;
+    let bestScore = Infinity;
+
+    for (let i = 0; i < this.llmDevices.length; i++) {
+      const llm = this.llmDevices[i];
+      const score = llm.lastUsed + (llm.errorCount * 60000);
+      if (score < bestScore) {
+        bestScore = score;
+        bestIndex = i;
+      }
+    }
+
+    const selected = this.llmDevices[bestIndex];
+    this.llmDevice = selected.device;
+    this.llmProviderType = selected.providerType;
+
+    // Mark as used
+    selected.lastUsed = Date.now();
+
+    this.console.log(`[Discovery] Selected LLM: ${selected.name}`);
+    return selected.device;
+  }
+
+  /** Mark an LLM as having an error */
+  private markLlmError(device: ChatCompletionDevice): void {
+    const llm = this.llmDevices.find(l => l.device === device);
+    if (llm) {
+      llm.errorCount++;
+      this.console.log(`[Discovery] ${llm.name} error count: ${llm.errorCount}`);
+    }
   }
 
   /** Get camera snapshot as ImageData */
@@ -495,6 +555,11 @@ Use the mount height to help estimate distances - objects at ground level will a
 
     // All formats failed
     if (lastError) {
+      // Track error for load balancing
+      if (llm) {
+        this.markLlmError(llm);
+      }
+
       const errorStr = String(lastError);
       if (isVisionFormatError(lastError)) {
         analysis.error = 'Vision/image analysis failed with all formats. Ensure you have a vision-capable model (e.g., gpt-4o, gpt-4-turbo, claude-3-sonnet) configured and the @scrypted/llm plugin supports vision.';

package/src/core/tracking-engine.ts

@@ -63,6 +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;
   /** 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 */
@@ -161,6 +163,7 @@ export class TrackingEngine {
     // Initialize spatial reasoning engine
     const spatialConfig: SpatialReasoningConfig = {
       enableLlm: config.useLlmDescriptions,
+      llmDeviceId: config.llmDeviceId,
       enableLandmarkLearning: config.enableLandmarkLearning ?? true,
       landmarkConfidenceThreshold: config.landmarkConfidenceThreshold ?? 0.7,
       contextCacheTtl: 60000, // 1 minute cache

package/src/main.ts

@@ -237,20 +237,21 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
       group: 'MQTT Integration',
     },
 
-    // Alert Settings
-    enableAlerts: {
-      title: 'Enable Alerts',
-      type: 'boolean',
-      defaultValue: true,
-      group: 'Alerts',
+    // Integrations
+    llmDevice: {
+      title: 'LLM Provider',
+      type: 'device',
+      deviceFilter: `interfaces.includes('ChatCompletion')`,
+      description: 'Select the LLM plugin to use for smart descriptions (e.g., OpenAI, Anthropic, Ollama)',
+      group: 'Integrations',
     },
     defaultNotifiers: {
-      title: 'Notifiers',
+      title: 'Notification Service',
       type: 'device',
       multiple: true,
       deviceFilter: `interfaces.includes('${ScryptedInterface.Notifier}')`,
-      description: 'Select one or more notifiers to receive alerts',
-      group: 'Alerts',
+      description: 'Select one or more notifiers to receive alerts (e.g., Pushover, Home Assistant)',
+      group: 'Integrations',
     },
 
     // Tracked Cameras
@@ -262,13 +263,6 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
       group: 'Cameras',
       description: 'Select cameras with object detection to track',
     },
-
-    // Alert Rules (stored as JSON)
-    alertRules: {
-      title: 'Alert Rules',
-      type: 'string',
-      hide: true,
-    },
   });
 
   constructor(nativeId?: ScryptedNativeId) {
@@ -368,7 +362,8 @@ 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,
-      llmDebounceInterval: (this.storageSettings.values.llmDebounceInterval as number || 10) * 1000,
+      llmDeviceId: this.storageSettings.values.llmDevice as string || undefined,
+      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,
       enableTransitTimeLearning: this.storageSettings.values.enableTransitTimeLearning as boolean ?? true,
@@ -697,95 +692,21 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
     // ==================== 5. Tracking ====================
     addGroup('Tracking');
 
-    // ==================== 6. AI & Spatial Reasoning ====================
+    // ==================== 6. Integrations ====================
+    addGroup('Integrations');
+
+    // ==================== 7. AI & Spatial Reasoning ====================
     addGroup('AI & Spatial Reasoning');
 
-    // ==================== 7. Auto-Topology Discovery ====================
+    // ==================== 8. Auto-Topology Discovery ====================
     addGroup('Auto-Topology Discovery');
 
-    // ==================== 8. Alerts ====================
-    addGroup('Alerts');
-
-    // Add alert rules configuration UI
-    const alertRules = this.alertManager.getRules();
-    const rulesHtml = this.generateAlertRulesHtml(alertRules);
-    settings.push({
-      key: 'alertRulesEditor',
-      title: 'Alert Rules',
-      type: 'html' as any,
-      value: rulesHtml,
-      group: 'Alerts',
-    });
-
     // ==================== 9. MQTT Integration ====================
     addGroup('MQTT Integration');
 
     return settings;
   }
 
-  private generateAlertRulesHtml(rules: any[]): string {
-    const ruleRows = rules.map(rule => `
-      <tr data-rule-id="${rule.id}">
-        <td style="padding:8px;border-bottom:1px solid #333;">
-          <input type="checkbox" ${rule.enabled ? 'checked' : ''}
-                 onchange="(function(el){var rules=JSON.parse(localStorage.getItem('sa-temp-rules')||'[]');var r=rules.find(x=>x.id==='${rule.id}');if(r)r.enabled=el.checked;localStorage.setItem('sa-temp-rules',JSON.stringify(rules));})(this)" />
-        </td>
-        <td style="padding:8px;border-bottom:1px solid #333;color:#fff;">${rule.name}</td>
-        <td style="padding:8px;border-bottom:1px solid #333;color:#888;">${rule.type}</td>
-        <td style="padding:8px;border-bottom:1px solid #333;">
-          <span style="padding:2px 8px;border-radius:4px;font-size:12px;background:${
-            rule.severity === 'critical' ? '#e94560' :
-            rule.severity === 'warning' ? '#f39c12' : '#3498db'
-          };color:white;">${rule.severity}</span>
-        </td>
-        <td style="padding:8px;border-bottom:1px solid #333;color:#888;">${Math.round(rule.cooldown / 1000)}s</td>
-      </tr>
-    `).join('');
-
-    const initCode = `localStorage.setItem('sa-temp-rules',JSON.stringify(${JSON.stringify(rules)}))`;
-    const saveCode = `(function(){var rules=JSON.parse(localStorage.getItem('sa-temp-rules')||'[]');fetch('/endpoint/@blueharford/scrypted-spatial-awareness/api/alert-rules',{method:'PUT',headers:{'Content-Type':'application/json'},body:JSON.stringify(rules)}).then(r=>r.json()).then(d=>{if(d.success)alert('Alert rules saved!');else alert('Error: '+d.error);}).catch(e=>alert('Error: '+e));})()`;
-
-    return `
-      <style>
-        .sa-rules-table { width:100%; border-collapse:collapse; margin-top:10px; }
-        .sa-rules-table th { text-align:left; padding:10px 8px; border-bottom:2px solid #e94560; color:#e94560; font-size:13px; }
-        .sa-save-rules-btn {
-          background: linear-gradient(135deg, #27ae60 0%, #2ecc71 100%);
-          color: white;
-          border: none;
-          padding: 10px 20px;
-          border-radius: 6px;
-          font-size: 14px;
-          font-weight: 600;
-          cursor: pointer;
-          margin-top: 15px;
-        }
-        .sa-save-rules-btn:hover { opacity: 0.9; }
-        .sa-rules-container { background:#16213e; border-radius:8px; padding:15px; }
-        .sa-rules-desc { color:#888; font-size:13px; margin-bottom:10px; }
-      </style>
-      <div class="sa-rules-container">
-        <p class="sa-rules-desc">Enable or disable alert types. Movement alerts notify you when someone moves between cameras.</p>
-        <table class="sa-rules-table">
-          <thead>
-            <tr>
-              <th style="width:40px;">On</th>
-              <th>Alert Type</th>
-              <th>Event</th>
-              <th>Severity</th>
-              <th>Cooldown</th>
-            </tr>
-          </thead>
-          <tbody>
-            ${ruleRows}
-          </tbody>
-        </table>
-        <button class="sa-save-rules-btn" onclick="${saveCode}">Save Alert Rules</button>
-        <script>(function(){${initCode}})();</script>
-      </div>
-    `;
-  }
-
   async putSetting(key: string, value: SettingValue): Promise<void> {
     await this.storageSettings.putSetting(key, value);
 
@@ -802,6 +723,7 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
       key === 'llmDebounceInterval' ||
       key === 'llmFallbackEnabled' ||
       key === 'llmFallbackTimeout' ||
+      key === 'llmDevice' ||
       key === 'enableTransitTimeLearning' ||
       key === 'enableConnectionSuggestions' ||
       key === 'enableLandmarkLearning' ||