@blueharford/scrypted-spatial-awareness 0.6.15 → 0.6.16

package/package.json

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

package/src/core/topology-discovery.ts

@@ -390,7 +390,7 @@ export class TopologyDiscoveryEngine {
               ],
             },
           ],
-          max_tokens: 1500,
+          max_tokens: 4000, // Increased for detailed scene analysis
           temperature: 0.3,
         });
 
@@ -403,7 +403,8 @@ export class TopologyDiscoveryEngine {
               jsonStr = jsonStr.replace(/```json?\n?/g, '').replace(/```$/g, '').trim();
             }
 
-            const parsed = JSON.parse(jsonStr);
+            // Try to recover truncated JSON
+            const parsed = this.parseJsonWithRecovery(jsonStr, cameraName);
 
             // Map parsed data to our types
             if (Array.isArray(parsed.landmarks)) {
@@ -544,6 +545,99 @@ export class TopologyDiscoveryEngine {
     return 'medium'; // Default to medium if not specified
   }
 
+  /** Try to parse JSON with recovery for truncated responses */
+  private parseJsonWithRecovery(jsonStr: string, context: string): any {
+    // First, try direct parse
+    try {
+      return JSON.parse(jsonStr);
+    } catch (e) {
+      // Log the raw response for debugging (first 500 chars)
+      this.console.log(`[Discovery] Raw LLM response for ${context} (first 500 chars): ${jsonStr.substring(0, 500)}...`);
+    }
+
+    // Try to recover truncated JSON by finding complete sections
+    try {
+      // Find where valid JSON might end (look for last complete object/array)
+      let recoveredJson = jsonStr;
+
+      // Try to close unclosed strings
+      const lastQuote = recoveredJson.lastIndexOf('"');
+      const lastColon = recoveredJson.lastIndexOf(':');
+      if (lastQuote > lastColon) {
+        // We might be in the middle of a string value
+        const beforeQuote = recoveredJson.substring(0, lastQuote);
+        const afterLastCompleteEntry = beforeQuote.lastIndexOf('},');
+        if (afterLastCompleteEntry > 0) {
+          recoveredJson = beforeQuote.substring(0, afterLastCompleteEntry + 1);
+        }
+      }
+
+      // Close any unclosed arrays/objects
+      let openBraces = (recoveredJson.match(/{/g) || []).length;
+      let closeBraces = (recoveredJson.match(/}/g) || []).length;
+      let openBrackets = (recoveredJson.match(/\[/g) || []).length;
+      let closeBrackets = (recoveredJson.match(/\]/g) || []).length;
+
+      // Add missing closing brackets/braces
+      while (closeBrackets < openBrackets) {
+        recoveredJson += ']';
+        closeBrackets++;
+      }
+      while (closeBraces < openBraces) {
+        recoveredJson += '}';
+        closeBraces++;
+      }
+
+      const recovered = JSON.parse(recoveredJson);
+      this.console.log(`[Discovery] Recovered truncated JSON for ${context}`);
+      return recovered;
+    } catch (recoveryError) {
+      // Last resort: try to extract just landmarks array
+      try {
+        const landmarksMatch = jsonStr.match(/"landmarks"\s*:\s*\[([\s\S]*?)(?:\]|$)/);
+        const zonesMatch = jsonStr.match(/"zones"\s*:\s*\[([\s\S]*?)(?:\]|$)/);
+
+        const result: any = { landmarks: [], zones: [], edges: {}, orientation: 'unknown' };
+
+        if (landmarksMatch) {
+          // Try to parse individual landmark objects
+          const landmarksStr = landmarksMatch[1];
+          const landmarkObjects = landmarksStr.match(/\{[^{}]*\}/g) || [];
+          result.landmarks = landmarkObjects.map((obj: string) => {
+            try {
+              return JSON.parse(obj);
+            } catch {
+              return null;
+            }
+          }).filter(Boolean);
+          this.console.log(`[Discovery] Extracted ${result.landmarks.length} landmarks from partial response for ${context}`);
+        }
+
+        if (zonesMatch) {
+          const zonesStr = zonesMatch[1];
+          const zoneObjects = zonesStr.match(/\{[^{}]*\}/g) || [];
+          result.zones = zoneObjects.map((obj: string) => {
+            try {
+              return JSON.parse(obj);
+            } catch {
+              return null;
+            }
+          }).filter(Boolean);
+          this.console.log(`[Discovery] Extracted ${result.zones.length} zones from partial response for ${context}`);
+        }
+
+        if (result.landmarks.length > 0 || result.zones.length > 0) {
+          return result;
+        }
+      } catch (extractError) {
+        // Give up
+      }
+
+      this.console.warn(`[Discovery] Could not recover JSON for ${context}`);
+      throw new Error(`Failed to parse LLM response: truncated or malformed JSON`);
+    }
+  }
+
   /** Resolve a camera reference (name or deviceId) to its deviceId */
   private resolveCameraRef(ref: string): string | null {
     if (!this.topology?.cameras || !ref) return null;