@blueharford/scrypted-spatial-awareness 0.5.6 → 0.5.8

package/out/main.nodejs.js

@@ -35058,45 +35058,15 @@ exports.ObjectCorrelator = ObjectCorrelator;
  * Uses RAG (Retrieval Augmented Generation) to provide rich contextual understanding
  * of movement across the property topology
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.SpatialReasoningEngine = void 0;
 exports.mediaObjectToBase64 = mediaObjectToBase64;
 exports.buildImageContent = buildImageContent;
 exports.isVisionFormatError = isVisionFormatError;
-const sdk_1 = __importStar(__webpack_require__(/*! @scrypted/sdk */ "./node_modules/@scrypted/sdk/dist/src/index.js"));
+const sdk_1 = __importDefault(__webpack_require__(/*! @scrypted/sdk */ "./node_modules/@scrypted/sdk/dist/src/index.js"));
 const topology_1 = __webpack_require__(/*! ../models/topology */ "./src/models/topology.ts");
 const { systemManager, mediaManager } = sdk_1.default;
 /**
@@ -35106,31 +35076,59 @@ const { systemManager, mediaManager } = sdk_1.default;
  */
 async function mediaObjectToBase64(mediaObject) {
     try {
-        console.log(`[Image] Converting MediaObject, mimeType=${mediaObject?.mimeType}`);
-        // Convert MediaObject to Buffer using mediaManager
-        const buffer = await mediaManager.convertMediaObjectToBuffer(mediaObject, sdk_1.ScryptedMimeTypes.Image);
-        if (!buffer) {
-            console.warn('[Image] convertMediaObjectToBuffer returned null/undefined');
-            return null;
+        const mimeType = mediaObject?.mimeType || 'image/jpeg';
+        console.log(`[Image] Converting MediaObject, mimeType=${mimeType}`);
+        // Use createMediaObject to ensure we have a proper MediaObject with mimeType
+        // Then convert to buffer - this should handle the conversion internally
+        let buffer;
+        try {
+            // Try direct conversion with the source mime type
+            buffer = await mediaManager.convertMediaObjectToBuffer(mediaObject, mimeType);
+        }
+        catch (convErr) {
+            console.warn(`[Image] Direct conversion failed, trying with explicit JPEG:`, convErr);
+            // Try creating a new MediaObject with explicit mimeType
+            try {
+                // Get raw data if available
+                const anyMedia = mediaObject;
+                if (typeof anyMedia.getData === 'function') {
+                    const rawData = await anyMedia.getData();
+                    if (rawData && Buffer.isBuffer(rawData) && rawData.length > 1000) {
+                        console.log(`[Image] Got raw data: ${rawData.length} bytes`);
+                        buffer = rawData;
+                    }
+                    else {
+                        console.warn(`[Image] getData returned invalid data`);
+                        return null;
+                    }
+                }
+                else {
+                    console.warn('[Image] No getData method available');
+                    return null;
+                }
+            }
+            catch (dataErr) {
+                console.warn('[Image] Alternate data fetch failed:', dataErr);
+                return null;
+            }
         }
-        console.log(`[Image] Buffer received: ${buffer.length} bytes`);
-        if (buffer.length === 0) {
-            console.warn('[Image] Buffer is empty (0 bytes)');
+        // Check if we got an actual Buffer (not a proxy)
+        const isRealBuffer = Buffer.isBuffer(buffer);
+        const bufferLength = isRealBuffer ? buffer.length : 0;
+        console.log(`[Image] Buffer: isBuffer=${isRealBuffer}, length=${bufferLength}`);
+        if (!isRealBuffer || bufferLength === 0) {
+            console.warn('[Image] Did not receive a valid Buffer');
             return null;
         }
         // Check if buffer is too small to be a valid image (< 1KB is suspicious)
-        if (buffer.length < 1000) {
-            // Log what the buffer contains - might be an error message
-            const bufferContent = buffer.toString('utf8').substring(0, 100);
-            console.warn(`[Image] Buffer too small (${buffer.length} bytes), content: ${bufferContent}`);
+        if (bufferLength < 1000) {
+            console.warn(`[Image] Buffer too small: ${bufferLength} bytes`);
             return null;
         }
         // Convert buffer to base64 (raw, no data URL prefix)
         const base64 = buffer.toString('base64');
-        // Determine MIME type - default to JPEG for camera images
-        const mediaType = mediaObject.mimeType?.split(';')[0] || 'image/jpeg';
-        console.log(`[Image] Converted to base64: ${base64.length} chars, type=${mediaType}`);
-        return { base64, mediaType };
+        console.log(`[Image] Converted to base64: ${base64.length} chars`);
+        return { base64, mediaType: 'image/jpeg' };
     }
     catch (e) {
         console.warn('[Image] Failed to convert MediaObject to base64:', e);