@blueharford/scrypted-spatial-awareness 0.6.15 → 0.6.17

package/out/main.nodejs.js

@@ -36481,18 +36481,31 @@ class TopologyDiscoveryEngine {
         for (const formatType of formatsToTry) {
             try {
                 this.console.log(`[Discovery] Trying ${formatType} image format for ${cameraName}...`);
+                // Build prompt with camera context (height)
+                const cameraNode = this.topology ? (0, topology_1.findCamera)(this.topology, cameraId) : null;
+                const mountHeight = cameraNode?.context?.mountHeight || 8;
+                const cameraRange = cameraNode?.fov?.range || 80;
+                // Add camera-specific context to the prompt
+                const contextPrefix = `CAMERA INFORMATION:
+- Camera Name: ${cameraName}
+- Mount Height: ${mountHeight} feet above ground
+- Approximate viewing range: ${cameraRange} feet
+
+Use the mount height to help estimate distances - objects at ground level will appear at different angles depending on distance from a camera mounted at ${mountHeight} feet.
+
+`;
                 // Build multimodal message with provider-specific image format
                 const result = await llm.getChatCompletion({
                     messages: [
                         {
                             role: 'user',
                             content: [
-                                { type: 'text', text: SCENE_ANALYSIS_PROMPT },
+                                { type: 'text', text: contextPrefix + SCENE_ANALYSIS_PROMPT },
                                 (0, spatial_reasoning_1.buildImageContent)(imageData, formatType),
                             ],
                         },
                     ],
-                    max_tokens: 1500,
+                    max_tokens: 4000, // Increased for detailed scene analysis
                     temperature: 0.3,
                 });
                 const content = result?.choices?.[0]?.message?.content;
@@ -36503,7 +36516,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 +36657,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)
@@ -43631,8 +43732,12 @@ exports.EDITOR_HTML = `<!DOCTYPE html>
       const fov = camera.fov || { mode: 'simple', angle: 90, direction: 0, range: 80 };
       // Convert stored pixel range to feet for display
       const rangeInFeet = Math.round(pixelsToFeet(fov.range || 80));
+      // Get mount height from context or default to 8
+      const mountHeight = camera.context?.mountHeight || 8;
       panel.innerHTML = '<h3>Camera Properties</h3>' +
         '<div class="form-group"><label>Name</label><input type="text" value="' + camera.name + '" onchange="updateCameraName(\\'' + camera.deviceId + '\\', this.value)"></div>' +
+        '<div class="form-group"><label>Mount Height (feet)</label><input type="number" value="' + mountHeight + '" min="1" max="40" step="0.5" onchange="updateCameraMountHeight(\\'' + camera.deviceId + '\\', this.value)"></div>' +
+        '<div style="font-size: 11px; color: #666; margin-top: -10px; margin-bottom: 10px;">Height affects distance estimation in discovery</div>' +
         '<div class="form-group"><label class="checkbox-group"><input type="checkbox" ' + (camera.isEntryPoint ? 'checked' : '') + ' onchange="updateCameraEntry(\\'' + camera.deviceId + '\\', this.checked)">Entry Point</label></div>' +
         '<div class="form-group"><label class="checkbox-group"><input type="checkbox" ' + (camera.isExitPoint ? 'checked' : '') + ' onchange="updateCameraExit(\\'' + camera.deviceId + '\\', this.checked)">Exit Point</label></div>' +
         '<h4 style="margin-top: 15px; margin-bottom: 10px; color: #888;">Field of View</h4>' +
@@ -43651,6 +43756,12 @@ exports.EDITOR_HTML = `<!DOCTYPE html>
     function updateCameraName(id, value) { const camera = topology.cameras.find(c => c.deviceId === id); if (camera) camera.name = value; updateUI(); }
     function updateCameraEntry(id, value) { const camera = topology.cameras.find(c => c.deviceId === id); if (camera) camera.isEntryPoint = value; }
     function updateCameraExit(id, value) { const camera = topology.cameras.find(c => c.deviceId === id); if (camera) camera.isExitPoint = value; }
+    function updateCameraMountHeight(id, value) {
+      const camera = topology.cameras.find(c => c.deviceId === id);
+      if (!camera) return;
+      if (!camera.context) camera.context = {};
+      camera.context.mountHeight = parseFloat(value) || 8;
+    }
     function updateCameraFov(id, field, value) {
       const camera = topology.cameras.find(c => c.deviceId === id);
       if (!camera) return;