@blueharford/scrypted-spatial-awareness 0.6.15 → 0.6.16

package/out/main.nodejs.js

@@ -36492,7 +36492,7 @@ class TopologyDiscoveryEngine {
                             ],
                         },
                     ],
-                    max_tokens: 1500,
+                    max_tokens: 4000, // Increased for detailed scene analysis
                     temperature: 0.3,
                 });
                 const content = result?.choices?.[0]?.message?.content;
@@ -36503,7 +36503,8 @@ class TopologyDiscoveryEngine {
                         if (jsonStr.startsWith('```')) {
                             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)) {
                             analysis.landmarks = parsed.landmarks.map((l) => ({
@@ -36643,6 +36644,93 @@ class TopologyDiscoveryEngine {
             return 'distant';
         return 'medium'; // Default to medium if not specified
     }
+    /** Try to parse JSON with recovery for truncated responses */
+    parseJsonWithRecovery(jsonStr, context) {
+        // 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 = { 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) => {
+                        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) => {
+                        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 */
     resolveCameraRef(ref) {
         if (!this.topology?.cameras || !ref)