react-native-litert-lm 0.2.0 → 0.2.2

package/android/src/main/java/com/margelo/nitro/dev/litert/litertlm/HybridLiteRTLM.kt

@@ -6,6 +6,9 @@
 package com.margelo.nitro.dev.litert.litertlm
 
 import android.util.Log
+import android.os.Debug
+import android.app.ActivityManager
+import android.content.Context
 import androidx.annotation.Keep
 import com.facebook.proguard.annotations.DoNotStrip
 import dev.litert.litertlm.LiteRTLMInitProvider
@@ -37,6 +40,20 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
 
     companion object {
         private const val TAG = "HybridLiteRTLM"
+        private val initLock = Any()
+        
+        /**
+         * Initialize the native library.
+         * Must be called from Application.onCreate() to register the HybridObject.
+         */
+        fun initialize() {
+            try {
+                // Call generated internal OnLoad to load the library
+                LiteRTLMOnLoad.initializeNative()
+            } catch (e: Throwable) {
+                Log.e(TAG, "Failed to initialize LiteRTLM native library", e)
+            }
+        }
     }
 
     init {
@@ -46,6 +63,9 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
     // LiteRT-LM Engine and Conversation
     private var engine: Engine? = null
     private var conversation: Conversation? = null
+    
+    @Volatile
+    private var isClosed = false
 
     // Conversation history for getHistory()
     private val history = mutableListOf<Message>()
@@ -75,64 +95,74 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
     // -------------------------------------------------------------------------
     override fun loadModel(modelPath: String, config: LLMConfig?): Promise<Unit> {
         return Promise.parallel {
-            Log.i(TAG, "loadModel: $modelPath")
-
-            // Clean up existing resources
-            close()
-
-            // Apply configuration
-            config?.let { cfg ->
-                cfg.backend?.let { backend = it }
-                cfg.temperature?.let { temperature = it }
-                cfg.topK?.let { topK = it.toInt() }
-                cfg.topP?.let { topP = it }
-                cfg.maxTokens?.let { maxTokens = it.toInt() }
-            }
-
-            try {
-                // Map our Backend enum to LiteRT-LM Backend enum
-                val lmBackend = when (backend) {
-                    Backend.GPU -> com.google.ai.edge.litertlm.Backend.GPU
-                    Backend.NPU -> {
-                        Log.i(TAG, "NPU backend requested - requires hardware support")
-                        com.google.ai.edge.litertlm.Backend.NPU
-                    }
-                    else -> com.google.ai.edge.litertlm.Backend.CPU
+            // Serialize initialization to prevent OOM from concurrent loads
+            synchronized(initLock) {
+                if (isClosed) {
+                    throw RuntimeException("Cannot load model: LiteRTLM instance is closed")
                 }
                 
-                // Vision backend: hardcoded to GPU (required by Gemma 3n)
-                val lmVisionBackend = com.google.ai.edge.litertlm.Backend.GPU
+                Log.i(TAG, "loadModel: $modelPath")
+    
+                // Clean up existing resources
+                // We call internal cleanup that doesn't set isClosed
+                cleanupInternal()
+    
+                // Apply configuration
+                config?.let { cfg ->
+                    cfg.backend?.let { backend = it }
+                    cfg.temperature?.let { temperature = it }
+                    cfg.topK?.let { topK = it.toInt() }
+                    cfg.topP?.let { topP = it }
+                    cfg.maxTokens?.let { maxTokens = it.toInt() }
+                }
+    
+                try {
+                    // Map our Backend enum to LiteRT-LM Backend enum
+                    val lmBackend = when (backend) {
+                        Backend.GPU -> com.google.ai.edge.litertlm.Backend.GPU
+                        Backend.NPU -> {
+                            Log.i(TAG, "NPU backend requested - requires hardware support")
+                            com.google.ai.edge.litertlm.Backend.NPU
+                        }
+                        else -> com.google.ai.edge.litertlm.Backend.CPU
+                    }
                     
-                // Audio backend: hardcoded to CPU (optimal for audio processing)
-                val lmAudioBackend = com.google.ai.edge.litertlm.Backend.CPU
-
-                Log.i(TAG, "Backend config: main=$lmBackend, vision=$lmVisionBackend (hardcoded), audio=$lmAudioBackend (hardcoded)")
-
-                // Get cache directory from application context
-                val cacheDirectory = LiteRTLMInitProvider.applicationContext?.cacheDir?.absolutePath
-                Log.i(TAG, "Using cache directory: $cacheDirectory")
-
-                // Create Engine configuration
-                val engineConfig = EngineConfig(
-                    modelPath = modelPath,
-                    backend = lmBackend,
-                    visionBackend = lmVisionBackend,
-                    audioBackend = lmAudioBackend,
-                    maxNumTokens = maxTokens,
-                    cacheDir = cacheDirectory
-                )
-
-                // Initialize Engine
-                engine = Engine(engineConfig).also { it.initialize() }
-                Log.i(TAG, "Engine created and initialized successfully")
-
-                // Create Conversation
-                createNewConversation()
-                Log.i(TAG, "Conversation created successfully")
-
-            } catch (e: Exception) {
-                Log.e(TAG, "Failed to load model: ${e.message}", e)
-                throw RuntimeException("Failed to load model: ${e.message}", e)
+                    // Vision backend: hardcoded to GPU (required by Gemma 3n)
+                    val lmVisionBackend = com.google.ai.edge.litertlm.Backend.GPU
+                        
+                    // Audio backend: hardcoded to CPU (optimal for audio processing)
+                    val lmAudioBackend = com.google.ai.edge.litertlm.Backend.CPU
+    
+                    Log.i(TAG, "Backend config: main=$lmBackend, vision=$lmVisionBackend (hardcoded), audio=$lmAudioBackend (hardcoded)")
+    
+                    // Get cache directory from application context
+                    val cacheDirectory = LiteRTLMInitProvider.applicationContext?.cacheDir?.absolutePath
+                    Log.i(TAG, "Using cache directory: $cacheDirectory")
+    
+                    // Create Engine configuration
+                    val engineConfig = EngineConfig(
+                        modelPath = modelPath,
+                        backend = lmBackend,
+                        visionBackend = lmVisionBackend,
+                        audioBackend = lmAudioBackend,
+                        maxNumTokens = maxTokens,
+                        cacheDir = cacheDirectory
+                    )
+    
+                    if (isClosed) return@synchronized
+                    
+                    // Initialize Engine
+                    engine = Engine(engineConfig).also { it.initialize() }
+                    Log.i(TAG, "Engine created and initialized successfully")
+    
+                    // Create Conversation
+                    createNewConversation()
+                    Log.i(TAG, "Conversation created successfully")
+    
+                } catch (e: Exception) {
+                    Log.e(TAG, "Failed to load model: ${e.message}", e)
+                    throw RuntimeException("Failed to load model: ${e.message}", e)
+                }
             }
         }
     }
@@ -233,18 +263,62 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
     // -------------------------------------------------------------------------
     // Multimodal methods
     // -------------------------------------------------------------------------
+    
+    /**
+     * Resize image if dimensions exceed maxDimension to prevent OOM.
+     * Gemma 3n's vision encoder is optimized for 512x512 or 1024x1024.
+     * Passing larger images can spike memory 500MB+.
+     */
+    private fun resizeImageIfNeeded(imagePath: String, maxDimension: Int = 1024): String {
+        val originalBitmap = android.graphics.BitmapFactory.decodeFile(imagePath)
+            ?: throw RuntimeException("Failed to decode image: $imagePath")
+
+        val width = originalBitmap.width
+        val height = originalBitmap.height
+
+        // If already within bounds, return original path
+        if (width <= maxDimension && height <= maxDimension) {
+            originalBitmap.recycle()
+            return imagePath
+        }
+
+        Log.i(TAG, "Resizing image from ${width}x${height} to fit ${maxDimension}px")
+
+        val scale = maxDimension.toFloat() / maxOf(width, height)
+        val newWidth = (width * scale).toInt()
+        val newHeight = (height * scale).toInt()
+
+        val resizedBitmap = android.graphics.Bitmap.createScaledBitmap(originalBitmap, newWidth, newHeight, true)
+        originalBitmap.recycle()
+
+        // Save to temp file
+        val cacheDir = LiteRTLMInitProvider.applicationContext?.cacheDir
+            ?: throw RuntimeException("Application context not available for image resizing")
+        val tempFile = java.io.File(cacheDir, "resized_${System.currentTimeMillis()}.jpg")
+        java.io.FileOutputStream(tempFile).use { out ->
+            resizedBitmap.compress(android.graphics.Bitmap.CompressFormat.JPEG, 90, out)
+        }
+        resizedBitmap.recycle()
+
+        Log.i(TAG, "Resized image saved to: ${tempFile.absolutePath} (${newWidth}x${newHeight})")
+        return tempFile.absolutePath
+    }
+
     override fun sendMessageWithImage(message: String, imagePath: String): Promise<String> {
         return Promise.parallel {
             ensureLoaded()
             Log.i(TAG, "sendMessageWithImage: $message, path=$imagePath")
 
+            // Resize image to prevent OOM on high-resolution photos
+            val processedImagePath = resizeImageIfNeeded(imagePath)
+
             // Create multimodal message
             // Use factory method Message.of passing a list of Content
             val textContent = Content.Text(message)
             
             val contentList = listOf(
                 textContent,
-                Content.ImageFile(imagePath)
+                Content.ImageFile(processedImagePath)
             )
 
             val userMsg = LiteRTMessage.of(contentList)
@@ -264,6 +338,115 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
         }
     }
 
+    override fun downloadModel(url: String, fileName: String, onProgress: ((Double) -> Unit)?): Promise<String> {
+        return Promise.parallel {
+            Log.i(TAG, "downloadModel: $url -> $fileName")
+            
+            val context = LiteRTLMInitProvider.applicationContext ?: throw RuntimeException("Context not available")
+            val modelsDir = java.io.File(context.filesDir, "models")
+            if (!modelsDir.exists()) {
+                modelsDir.mkdirs()
+            }
+            
+            val modelFile = java.io.File(modelsDir, fileName)
+            val tempFile = java.io.File(modelsDir, "$fileName.tmp")
+            
+            // Check if file exists and has content
+            if (modelFile.exists() && modelFile.length() > 0) {
+                Log.i(TAG, "Model already exists at: ${modelFile.absolutePath}")
+                onProgress?.invoke(1.0)
+                return@parallel modelFile.absolutePath
+            }
+            
+            Log.i(TAG, "Downloading model to temp file: ${tempFile.absolutePath}")
+            onProgress?.invoke(0.0)
+            
+            try {
+                val connection = java.net.URL(url).openConnection() as java.net.HttpURLConnection
+                connection.connectTimeout = 15000 // 15s
+                connection.readTimeout = 0 // Infinite for large files
+                connection.doInput = true
+                connection.connect()
+                
+                if (connection.responseCode != java.net.HttpURLConnection.HTTP_OK) {
+                    throw RuntimeException("Failed to download model: HTTP ${connection.responseCode}")
+                }
+                
+                val contentLength = connection.contentLengthLong // Use long for large files
+                val input = connection.inputStream
+                val output = java.io.FileOutputStream(tempFile)
+                
+                val buffer = ByteArray(8 * 1024)
+                var bytesRead: Int
+                var totalBytesRead = 0L
+                var lastProgressUpdate = 0L
+                
+                while (input.read(buffer).also { bytesRead = it } != -1) {
+                    output.write(buffer, 0, bytesRead)
+                    totalBytesRead += bytesRead
+                    
+                    if (contentLength > 0 && onProgress != null) {
+                        val currentTime = System.currentTimeMillis()
+                        // Update roughly every 100ms to avoid flooding JS bridge
+                        if (currentTime - lastProgressUpdate > 100) {
+                            val progress = totalBytesRead.toDouble() / contentLength.toDouble()
+                            onProgress(progress)
+                            lastProgressUpdate = currentTime
+                        }
+                    }
+                }
+                
+                output.flush()
+                output.close()
+                input.close()
+                connection.disconnect()
+                
+                // Atomic rename
+                if (tempFile.renameTo(modelFile)) {
+                    Log.i(TAG, "Download complete and renamed to: ${modelFile.absolutePath}")
+                    onProgress?.invoke(1.0)
+                    return@parallel modelFile.absolutePath
+                } else {
+                    throw RuntimeException("Failed to rename temp file to model file")
+                }
+                
+            } catch (e: Exception) {
+                Log.e(TAG, "Download failed", e)
+                if (tempFile.exists()) {
+                    tempFile.delete()
+                }
+                throw RuntimeException("Download failed: ${e.message}", e)
+            }
+        }
+    }
+
+    override fun deleteModel(fileName: String): Promise<Unit> {
+        return Promise.parallel {
+            Log.i(TAG, "deleteModel: $fileName")
+            val context = LiteRTLMInitProvider.applicationContext ?: throw RuntimeException("Context not available")
+            val modelsDir = java.io.File(context.filesDir, "models")
+            val modelFile = java.io.File(modelsDir, fileName)
+            
+            if (modelFile.exists()) {
+                val deleted = modelFile.delete()
+                if (deleted) {
+                    Log.i(TAG, "Deleted model: ${modelFile.absolutePath}")
+                    // Ensure engine references are cleared if they point to this file
+                    // We use cleanupInternal() which releases resources WITHOUT marking the instance as closed.
+                    if (engine != null) {
+                        Log.i(TAG, "Cleaning up engine after deleting model file.")
+                        cleanupInternal()
+                    }
+                } else {
+                    Log.e(TAG, "Failed to delete model: ${modelFile.absolutePath}")
+                    throw RuntimeException("Failed to delete model: ${modelFile.absolutePath}")
+                }
+            } else {
+                Log.w(TAG, "Model not found for deletion: ${modelFile.absolutePath}")
+            }
+        }
+    }
+
     override fun sendMessageWithAudio(message: String, audioPath: String): Promise<String> {
         return Promise.parallel {
             ensureLoaded()
@@ -316,12 +499,72 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
         return lastStats
     }
 
+    override fun getMemoryUsage(): MemoryUsage {
+        // Native heap: allocated bytes from Debug APIs (most accurate for native allocations)
+        val nativeHeapBytes = Debug.getNativeHeapAllocatedSize().toDouble()
+
+        // Process RSS: read from /proc/self/status (VmRSS) in kB
+        var residentBytes = 0.0
+        try {
+            java.io.File("/proc/self/status").forEachLine { line ->
+                if (line.startsWith("VmRSS:")) {
+                    val kb = line.substringAfter("VmRSS:").trim().split("\\s+".toRegex())[0].toDoubleOrNull()
+                    if (kb != null) {
+                        residentBytes = kb * 1024.0
+                    }
+                    return@forEachLine
+                }
+            }
+        } catch (e: Exception) {
+            Log.w(TAG, "Failed to read /proc/self/status: ${e.message}")
+        }
+
+        // Available memory and low-memory flag from ActivityManager
+        var availableMemoryBytes = 0.0
+        var isLowMemory = false
+        try {
+            val context = LiteRTLMInitProvider.applicationContext
+            if (context != null) {
+                val activityManager = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
+                val memInfo = ActivityManager.MemoryInfo()
+                activityManager.getMemoryInfo(memInfo)
+                availableMemoryBytes = memInfo.availMem.toDouble()
+                isLowMemory = memInfo.lowMemory
+            }
+        } catch (e: Exception) {
+            Log.w(TAG, "Failed to get ActivityManager memory info: ${e.message}")
+        }
+
+        return MemoryUsage(
+            nativeHeapBytes = nativeHeapBytes,
+            residentBytes = residentBytes,
+            availableMemoryBytes = availableMemoryBytes,
+            isLowMemory = isLowMemory
+        )
+    }
+
     override fun close() {
         Log.d(TAG, "Closing resources")
+        isClosed = true
+        cleanupInternal()
+    }
+
+    private fun cleanupInternal() {
         try {
             conversation = null
-            engine = null // Engine destructor should handle cleanup
-            // In C++ we'd close explicitly, Kotlin GC helps but explicit close method is better if SDK has it
+            // Explicitly close engine if it supports it to free native memory immediately
+            // Assuming Engine implements AutoCloseable or has close()
+            if (engine is AutoCloseable) {
+                (engine as AutoCloseable).close()
+            } else {
+                 // Try reflection or just null it if no close method
+                try {
+                    engine?.javaClass?.getMethod("close")?.invoke(engine)
+                } catch (e: Exception) {
+                    // Method not found, rely on GC
+                }
+            }
+            engine = null 
         } catch (e: Exception) {
             Log.e(TAG, "Error closing resources", e)
         }

package/cpp/HybridLiteRTLM.cpp

@@ -283,16 +283,34 @@ std::string HybridLiteRTLM::sendMessageWithImage(
   return response->content;
   
 #else
-  // Stub: just process text with image path noted
-  // Verify file exists at least
-  std::ifstream f(imagePath.c_str());
-  if (!f.good()) {
-     // Don't crash, just log/stub
-  }
-  return sendMessage(message + " [Image: " + imagePath + "]");
+  // iOS: LiteRT-LM SDK not yet available, throw clear error
+  throw std::runtime_error(
+      "sendMessageWithImage is not supported on iOS. "
+      "LiteRT-LM iOS SDK is not yet available. "
+      "Please use text-only sendMessage() for now.");
+#endif
+}
+
 #endif
 }
 
+//------------------------------------------------------------------------------
+// downloadModel - Download model file from URL
+//------------------------------------------------------------------------------
+std::future<std::string> HybridLiteRTLM::downloadModel(
+    const std::string& url,
+    const std::string& fileName,
+    const std::optional<std::function<void(double)>>& onProgress) {
+  
+  // Return a future that throws an exception
+  return std::async(std::launch::async, []() -> std::string {
+    throw std::runtime_error(
+        "downloadModel is not supported on iOS yet. "
+        "Please download the model manually using a separate library."
+    );
+  });
+}
+
 //------------------------------------------------------------------------------
 // sendMessageWithAudio - Multimodal audio + text
 //------------------------------------------------------------------------------
@@ -349,8 +367,11 @@ std::string HybridLiteRTLM::sendMessageWithAudio(
   return response->content;
   
 #else
-  // Stub: just process text with audio path noted
-  return sendMessage(message + " [Audio: " + audioPath + "]");
+  // iOS: LiteRT-LM SDK not yet available, throw clear error
+  throw std::runtime_error(
+      "sendMessageWithAudio is not supported on iOS. "
+      "LiteRT-LM iOS SDK is not yet available. "
+      "Please use text-only sendMessage() for now.");
 #endif
 }
 
@@ -497,6 +518,85 @@ GenerationStats HybridLiteRTLM::getStats() {
   return lastStats_;
 }
 
+//------------------------------------------------------------------------------
+// getMemoryUsage - Return real memory usage from OS
+//------------------------------------------------------------------------------
+MemoryUsage HybridLiteRTLM::getMemoryUsage() {
+  double nativeHeapBytes = 0;
+  double residentBytes = 0;
+  double availableMemoryBytes = 0;
+  bool isLowMemory = false;
+
+#ifdef __APPLE__
+  // Get process memory info via Mach APIs
+  struct mach_task_basic_info taskInfo;
+  mach_msg_type_number_t infoCount = MACH_TASK_BASIC_INFO_COUNT;
+  if (task_info(mach_task_self(), MACH_TASK_BASIC_INFO,
+                (task_info_t)&taskInfo, &infoCount) == KERN_SUCCESS) {
+    residentBytes = static_cast<double>(taskInfo.resident_size);
+  }
+
+  // Get system-wide memory pressure
+  vm_statistics64_data_t vmStats;
+  mach_msg_type_number_t vmCount = HOST_VM_INFO64_COUNT;
+  if (host_statistics64(mach_host_self(), HOST_VM_INFO64,
+                        (host_info64_t)&vmStats, &vmCount) == KERN_SUCCESS) {
+    vm_size_t pageSize;
+    host_page_size(mach_host_self(), &pageSize);
+    availableMemoryBytes = static_cast<double>(vmStats.free_count) * pageSize;
+    // Consider low memory if free pages < 10% of total active+inactive+free
+    uint64_t totalPages = vmStats.active_count + vmStats.inactive_count + vmStats.free_count;
+    isLowMemory = (totalPages > 0) &&
+                  (static_cast<double>(vmStats.free_count) / totalPages < 0.1);
+  }
+
+  // malloc_size is per-allocation; use resident_size as native heap proxy
+  nativeHeapBytes = residentBytes;
+#endif
+
+#ifdef __ANDROID__
+  // Parse /proc/self/status for VmRSS (resident set size)
+  std::ifstream statusFile("/proc/self/status");
+  if (statusFile.is_open()) {
+    std::string line;
+    while (std::getline(statusFile, line)) {
+      if (line.rfind("VmRSS:", 0) == 0) {
+        // Format: "VmRSS:    123456 kB"
+        std::istringstream iss(line.substr(6));
+        double kbValue = 0;
+        iss >> kbValue;
+        residentBytes = kbValue * 1024.0;
+        break;
+      }
+    }
+  }
+
+  // Use mallinfo for native heap
+  struct mallinfo mi = mallinfo();
+  nativeHeapBytes = static_cast<double>(mi.uordblks); // total allocated space
+
+  // Parse /proc/meminfo for available memory
+  std::ifstream memFile("/proc/meminfo");
+  if (memFile.is_open()) {
+    std::string line;
+    while (std::getline(memFile, line)) {
+      if (line.rfind("MemAvailable:", 0) == 0) {
+        std::istringstream iss(line.substr(13));
+        double kbValue = 0;
+        iss >> kbValue;
+        availableMemoryBytes = kbValue * 1024.0;
+        break;
+      }
+    }
+  }
+
+  // Consider low if available < 256MB
+  isLowMemory = availableMemoryBytes > 0 && availableMemoryBytes < 256.0 * 1024 * 1024;
+#endif
+
+  return MemoryUsage{nativeHeapBytes, residentBytes, availableMemoryBytes, isLowMemory};
+}
+
 //------------------------------------------------------------------------------
 // close - Release all native resources
 //------------------------------------------------------------------------------

package/cpp/HybridLiteRTLM.hpp

@@ -21,6 +21,16 @@
 #include "litert/lm/types.h"
 #endif
 
+// Memory usage headers
+#ifdef __APPLE__
+#include <mach/mach.h>
+#include <mach/mach_host.h>
+#endif
+#ifdef __ANDROID__
+#include <malloc.h>
+#include <fstream>
+#endif
+
 #include <string>
 #include <optional>
 #include <vector>
@@ -58,6 +68,10 @@ public:
   
   std::string sendMessageWithImage(const std::string& message,
                                    const std::string& imagePath) override;
+
+  std::future<std::string> downloadModel(const std::string& url, 
+                                         const std::string& fileName,
+                                         const std::optional<std::function<void(double)>>& onProgress) override;
   
   std::string sendMessageWithAudio(const std::string& message,
                                    const std::string& audioPath) override;
@@ -75,6 +89,8 @@ public:
   
   GenerationStats getStats() override;
   
+  MemoryUsage getMemoryUsage() override;
+  
   void close() override;
 
 private:

package/cpp/cpp-adapter.cpp

@@ -2,12 +2,20 @@
 /// cpp-adapter.cpp
 /// JNI Entry Point - Required by Nitrogen to register Kotlin HybridObjects
 ///
+/// Updated for react-native-nitro-modules v0.34+:
+/// Uses facebook::jni::initialize() directly with registerAllNatives().
+///
 
 #include <jni.h>
+#include <fbjni/fbjni.h>
 #include "LiteRTLMOnLoad.hpp"
 
 // JNI_OnLoad is called when the native library is loaded via System.loadLibrary()
-// This is where we initialize the Nitrogen bridge and register all Kotlin HybridObjects
+// This is where we initialize the Nitrogen bridge and register all Kotlin HybridObjects.
+// The new v0.34 API allows registering custom C++ native JNI classes/functions
+// alongside Nitrogen's auto-generated registrations.
 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
-    return margelo::nitro::litertlm::initialize(vm);
+    return facebook::jni::initialize(vm, []() {
+        margelo::nitro::litertlm::registerAllNatives();
+    });
 }

package/lib/hooks.d.ts

@@ -0,0 +1,41 @@
+import { LiteRTLM, LLMConfig } from "./index";
+import type { MemoryTracker, MemoryTrackerSummary } from "./memoryTracker";
+export interface UseModelConfig extends LLMConfig {
+    autoLoad?: boolean;
+    /**
+     * Enable memory tracking using native ArrayBuffers (v0.34+).
+     * When enabled, memory usage is tracked after each inference call
+     * using `NitroModules.createNativeArrayBuffer()` for zero-copy storage.
+     * @default false
+     */
+    enableMemoryTracking?: boolean;
+    /**
+     * Maximum number of memory snapshots to store.
+     * Each snapshot uses 32 bytes of native memory.
+     * @default 256
+     */
+    maxMemorySnapshots?: number;
+}
+export interface UseModelResult {
+    model: LiteRTLM | null;
+    isReady: boolean;
+    isGenerating: boolean;
+    downloadProgress: number;
+    error: string | null;
+    generate: (prompt: string) => Promise<string>;
+    reset: () => void;
+    deleteModel: (fileName: string) => Promise<void>;
+    load: () => Promise<void>;
+    /**
+     * Memory tracker instance (available when enableMemoryTracking is true).
+     * Uses native ArrayBuffers allocated via `NitroModules.createNativeArrayBuffer()`
+     * for efficient, zero-copy memory usage tracking.
+     */
+    memoryTracker: MemoryTracker | null;
+    /**
+     * Current memory tracking summary (null if tracking is disabled).
+     * Updates automatically after each inference call.
+     */
+    memorySummary: MemoryTrackerSummary | null;
+}
+export declare function useModel(pathOrUrl: string, config?: UseModelConfig): UseModelResult;