react-native-litert-lm 0.1.0 → 0.1.1

package/README.md

@@ -9,8 +9,9 @@ High-performance LLM inference for React Native powered by [LiteRT-LM](https://g
 - ⚡ **GPU Acceleration** - GPU delegate (Android), Metal (iOS when available)
 - 📦 **Bundled Tokenizer** - No separate tokenization library needed
 - 🔄 **Streaming Support** - Token-by-token generation callbacks
-- 📱 **Cross-Platform** - Android API 26+ (iOS coming soon)
-- 🚧 **Multimodal** - Image and audio input (Coming Soon to Android)
+- 📱 **Cross-Platform** - Android API 26+
+- 🚧 **Multimodal** - Image and audio input (Coming Soon)
+- 🧵 **Async API** - Non-blocking inference to prevent UI freezes
 
 ## Status
 
@@ -86,15 +87,15 @@ import { createLLM } from "react-native-litert-lm";
 
 const llm = createLLM();
 
-// Load a Gemma 3n model
-llm.loadModel("/path/to/gemma-3n-e2b.litertlm", {
+// Load a Gemma 3n model (async)
+await llm.loadModel("/path/to/gemma-3n-e2b.litertlm", {
   backend: "gpu",
   temperature: 0.7,
   maxTokens: 512,
 });
 
-// Generate response
-const response = llm.sendMessage("What is the capital of France?");
+// Generate response (async)
+const response = await llm.sendMessage("What is the capital of France?");
 console.log(response);
 
 // Clean up
@@ -114,13 +115,15 @@ llm.sendMessageAsync("Tell me a story", (token, done) => {
 
 ```typescript
 // Image input (for vision models)
-const response = llm.sendMessageWithImage(
+// Note: Currently throws error on Android (Coming Soon)
+const response = await llm.sendMessageWithImage(
   "What's in this image?",
   "/path/to/image.jpg",
 );
 
 // Audio input (for audio models)
-const transcription = llm.sendMessageWithAudio(
+// Note: Currently throws error on Android (Coming Soon)
+const transcription = await llm.sendMessageWithAudio(
   "Transcribe this audio",
   "/path/to/audio.wav",
 );
@@ -152,7 +155,7 @@ Download `.litertlm` models from [HuggingFace](https://huggingface.co/litert-com
 
 Creates a new LLM inference engine instance.
 
-### `loadModel(path, config?)`
+### `loadModel(path, config?): Promise<void>`
 
 - `path: string` - Absolute path to `.litertlm` file
 - `config.backend` - `'cpu'` | `'gpu'` | `'npu'` (default: `'gpu'`)
@@ -172,19 +175,19 @@ Creates a new LLM inference engine instance.
 
 > ⚠️ **NPU Note**: NPU acceleration requires compatible hardware (Qualcomm Hexagon, MediaTek APU, etc.). If unavailable, LiteRT-LM automatically falls back to GPU.
 
-### `sendMessage(message): string`
+### `sendMessage(message): Promise<string>`
 
-Blocking generation. Returns complete response.
+Blocking generation (executed on background thread). Returns complete response.
 
 ### `sendMessageAsync(message, callback)`
 
 Streaming generation. Callback receives `(token, isDone)`.
 
-### `sendMessageWithImage(message, imagePath): string`
+### `sendMessageWithImage(message, imagePath): Promise<string>`
 
 Send a message with an image attachment (for vision models).
 
-### `sendMessageWithAudio(message, audioPath): string`
+### `sendMessageWithAudio(message, audioPath): Promise<string>`
 
 Send a message with an audio attachment (for audio models).
 

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

@@ -19,6 +19,7 @@ import com.margelo.nitro.dev.litert.litertlm.HybridLiteRTLMSpec
 import com.margelo.nitro.dev.litert.litertlm.LLMConfig
 import com.margelo.nitro.dev.litert.litertlm.Message
 import com.margelo.nitro.dev.litert.litertlm.Role
+import com.margelo.nitro.core.Promise
 
 // Alias to avoid confusion with our generated Message type
 typealias LiteRTMessage = com.google.ai.edge.litertlm.Message
@@ -35,6 +36,10 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
         private const val TAG = "HybridLiteRTLM"
     }
 
+    init {
+        LiteRTLMRegistry.register(this)
+    }
+
     // LiteRT-LM Engine and Conversation
     private var engine: Engine? = null
     private var conversation: Conversation? = null
@@ -60,116 +65,124 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
     private var maxTokens: Int = 1024
 
     override val memorySize: Long
-        get() = 10L * 1024L * 1024L // ~10MB estimate
+        get() = 1024L * 1024L * 1024L // ~1GB (models are large)
 
     // -------------------------------------------------------------------------
     // loadModel - Initialize LiteRT-LM Engine and Conversation
     // -------------------------------------------------------------------------
-    override fun loadModel(modelPath: String, config: LLMConfig?) {
-        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() }
-        }
+    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
+            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
                 }
-                else -> com.google.ai.edge.litertlm.Backend.CPU
-            }
-            
-            // 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
-            // LiteRT-LM needs this to store temporary compiled model files
-            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
-            )
-
-            // Create Engine (heavyweight - loads model)
-            engine = Engine(engineConfig).also { it.initialize() }
-            Log.i(TAG, "Engine created and initialized successfully")
-
-            // Create Conversation (lightweight - holds KV cache)
-            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
+                )
+
+                // 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)
+            }
         }
     }
 
     // -------------------------------------------------------------------------
-    // sendMessage - Blocking text inference
+    // sendMessage - Helper for one-shot generation (internally uses Async)
     // -------------------------------------------------------------------------
-    override fun sendMessage(message: String): String {
-        ensureLoaded()
-
-        // Add user message to history
-        history.add(Message(Role.USER, message))
-
-        // Pre-process message (chat template)
-        Log.i(TAG, "sendMessage: $message")
-        
-        // Blocking inference
-        // LiteRT-LM expects a Message object, not String
-        val userMsg = LiteRTMessage.of(message)
-        val responseMsg = conversation!!.sendMessage(userMsg)
-        
-        // Extract text from response Message
-        val response = responseMsg.contents
-            .filterIsInstance<com.google.ai.edge.litertlm.Content.Text>()
-            .joinToString("") { it.text } 
-        
-        // Add model response to history
-        history.add(Message(Role.MODEL, response))
-        
-        // Update stats (mock/approximate for now as SDK doesn't return full stats for sync call)
-        lastStats = GenerationStats(
-            promptTokens = message.length / 4.0,
-            completionTokens = response.length / 4.0,
-            totalTokens = (message.length + response.length) / 4.0,
-            timeToFirstToken = 0.0,
-            totalTime = 0.0,
-            tokensPerSecond = 0.0
-        )
-        
-        return response
+    override fun sendMessage(message: String): Promise<String> {
+        // Implement Promise-based sendMessage using suspend coroutine logic wrapped in Promise
+        // Since Promise.parallel expects a blocking block returning T, 
+        // and sendMessageAsync is callback-based, we need to bridge them.
+        // HOWEVER, we can just use the synchronous `sendMessage` API of the SDK 
+        // inside the `Promise.parallel` block, which moves it off the main thread!
+        return Promise.parallel {
+            ensureLoaded()
+
+            // Add user message to history
+            history.add(Message(Role.USER, message))
+            Log.i(TAG, "sendMessage (Promise): $message")
+            
+            // Blocking inference (safe here because we are in Promise.parallel worker thread)
+            val userMsg = LiteRTMessage.of(message)
+            val responseMsg = conversation!!.sendMessage(userMsg)
+            
+            // Extract text
+            val response = responseMsg.contents
+                .filterIsInstance<com.google.ai.edge.litertlm.Content.Text>()
+                .joinToString("") { it.text } 
+            
+            // Add model response to history
+            history.add(Message(Role.MODEL, response))
+            
+            // Update stats
+            lastStats = GenerationStats(
+                promptTokens = message.length / 4.0,
+                completionTokens = response.length / 4.0,
+                totalTokens = (message.length + response.length) / 4.0,
+                timeToFirstToken = 0.0,
+                totalTime = 0.0,
+                tokensPerSecond = 0.0
+            )
+            
+            response // Return the string
+        }
     }
 
     // -------------------------------------------------------------------------
     // sendMessageAsync - Streaming inference
     // -------------------------------------------------------------------------
     override fun sendMessageAsync(message: String, onToken: (String, Boolean) -> Unit) {
+        // This is already async (void return), so we execute immediately on the calling thread
+        // (which is the Nitro specialized thread, not Main).
+        // The SDK's sendMessageAsync is non-blocking anyway.
         ensureLoaded()
 
         // Add user message to history
@@ -206,12 +219,8 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
         }
 
         try {
-            // Construct Message object
             val userMsg = LiteRTMessage.of(message)
-            
-            // LiteRT-LM async call - SDK handles threading
             conversation!!.sendMessageAsync(userMsg, listener)
-            
         } catch (e: Exception) {
             Log.e(TAG, "Failed into initiate async generation", e)
             onToken("Error: ${e.message}", true)
@@ -221,14 +230,18 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
     // -------------------------------------------------------------------------
     // Multimodal methods
     // -------------------------------------------------------------------------
-    override fun sendMessageWithImage(message: String, imagePath: String): String {
-        // TODO: Implement image loading from path
-        throw RuntimeException("Multimodal (Image) not yet implemented in this wrapper")
+    override fun sendMessageWithImage(message: String, imagePath: String): Promise<String> {
+        return Promise.parallel {
+             // TODO: Implement image loading from path
+            throw RuntimeException("Multimodal (Image) not yet implemented in this wrapper")
+        }
     }
 
-    override fun sendMessageWithAudio(message: String, audioPath: String): String {
-        // TODO: Implement audio loading from path
-        throw RuntimeException("Multimodal (Audio) not yet implemented in this wrapper")
+    override fun sendMessageWithAudio(message: String, audioPath: String): Promise<String> {
+        return Promise.parallel {
+            // TODO: Implement audio loading from path
+            throw RuntimeException("Multimodal (Audio) not yet implemented in this wrapper")
+        }
     }
 
     // -------------------------------------------------------------------------

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

@@ -0,0 +1,32 @@
+package com.margelo.nitro.dev.litert.litertlm
+
+import java.util.Collections
+import java.util.WeakHashMap
+import android.util.Log
+
+/**
+ * Global registry to track active LiteRTLM instances.
+ * Used for memory trimming and cleanup.
+ */
+object LiteRTLMRegistry {
+    private const val TAG = "LiteRTLMRegistry"
+    
+    // Use WeakSet-like structure to prevent leaks
+    private val instances = Collections.newSetFromMap(WeakHashMap<HybridLiteRTLM, Boolean>())
+
+    fun register(instance: HybridLiteRTLM) {
+        synchronized(instances) {
+            instances.add(instance)
+        }
+    }
+
+    fun onTrimMemory(level: Int) {
+        Log.w(TAG, "Received memory warning (level=$level). Releasing resources...")
+        synchronized(instances) {
+            instances.forEach { it.close() }
+            // Note: We don't clear the set here, as close() should be idempotent
+            // and the instance might still be ref-counted by JS. 
+            // We just ensure the HEAVY native resources are gone.
+        }
+    }
+}

package/android/src/main/java/dev/litert/litertlm/LiteRTLMInitProvider.kt

@@ -17,6 +17,20 @@ class LiteRTLMInitProvider : ContentProvider() {
     override fun onCreate(): Boolean {
         applicationContext = context?.applicationContext
         Log.i(TAG, "LiteRTLMInitProvider initialized with context: $applicationContext")
+        
+        applicationContext?.registerComponentCallbacks(object : android.content.ComponentCallbacks2 {
+            override fun onTrimMemory(level: Int) {
+                if (level >= android.content.ComponentCallbacks2.TRIM_MEMORY_RUNNING_LOW) {
+                    com.margelo.nitro.dev.litert.litertlm.LiteRTLMRegistry.onTrimMemory(level)
+                }
+            }
+
+            override fun onConfigurationChanged(newConfig: android.content.res.Configuration) {}
+            override fun onLowMemory() {
+                com.margelo.nitro.dev.litert.litertlm.LiteRTLMRegistry.onTrimMemory(android.content.ComponentCallbacks2.TRIM_MEMORY_COMPLETE)
+            }
+        })
+        
         return true
     }
 

package/lib/specs/LiteRTLM.nitro.d.ts

@@ -108,31 +108,30 @@ export interface LiteRTLM extends HybridObject<{
 }> {
     /**
      * Load a .litertlm model file.
-     * @param modelPath Absolute path to the .litertlm file.
      * @param config Optional configuration for backend and sampling.
      * @throws Error if the model cannot be loaded.
      */
-    loadModel(modelPath: string, config?: LLMConfig): void;
+    loadModel(modelPath: string, config?: LLMConfig): Promise<void>;
     /**
      * Send a text message and get the complete response (blocking).
      * @param message User message text.
      * @returns The model's response text.
      */
-    sendMessage(message: string): string;
+    sendMessage(message: string): Promise<string>;
     /**
      * Send a text message with an image (multimodal).
      * @param message User message text.
      * @param imagePath Absolute path to an image file.
      * @returns The model's response text.
      */
-    sendMessageWithImage(message: string, imagePath: string): string;
+    sendMessageWithImage(message: string, imagePath: string): Promise<string>;
     /**
      * Send a text message with audio (multimodal).
      * @param message User message text.
      * @param audioPath Absolute path to an audio file (WAV).
      * @returns The model's response text.
      */
-    sendMessageWithAudio(message: string, audioPath: string): string;
+    sendMessageWithAudio(message: string, audioPath: string): Promise<string>;
     /**
      * Send a message with streaming response.
      * Tokens are delivered via callback as they are generated.

package/nitrogen/generated/android/c++/JHybridLiteRTLMSpec.cpp

@@ -18,6 +18,9 @@ namespace margelo::nitro::litertlm { struct LLMConfig; }
 // Forward declaration of `Backend` to properly resolve imports.
 namespace margelo::nitro::litertlm { enum class Backend; }
 
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include <NitroModules/JUnit.hpp>
 #include <string>
 #include "Message.hpp"
 #include <vector>
@@ -74,24 +77,68 @@ namespace margelo::nitro::litertlm {
   
 
   // Methods
-  void JHybridLiteRTLMSpec::loadModel(const std::string& modelPath, const std::optional<LLMConfig>& config) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* modelPath */, jni::alias_ref<JLLMConfig> /* config */)>("loadModel");
-    method(_javaPart, jni::make_jstring(modelPath), config.has_value() ? JLLMConfig::fromCpp(config.value()) : nullptr);
+  std::shared_ptr<Promise<void>> JHybridLiteRTLMSpec::loadModel(const std::string& modelPath, const std::optional<LLMConfig>& config) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* modelPath */, jni::alias_ref<JLLMConfig> /* config */)>("loadModel");
+    auto __result = method(_javaPart, jni::make_jstring(modelPath), config.has_value() ? JLLMConfig::fromCpp(config.value()) : nullptr);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
   }
-  std::string JHybridLiteRTLMSpec::sendMessage(const std::string& message) {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>(jni::alias_ref<jni::JString> /* message */)>("sendMessage");
+  std::shared_ptr<Promise<std::string>> JHybridLiteRTLMSpec::sendMessage(const std::string& message) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* message */)>("sendMessage");
     auto __result = method(_javaPart, jni::make_jstring(message));
-    return __result->toStdString();
+    return [&]() {
+      auto __promise = Promise<std::string>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JString>(__boxedResult);
+        __promise->resolve(__result->toStdString());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
   }
-  std::string JHybridLiteRTLMSpec::sendMessageWithImage(const std::string& message, const std::string& imagePath) {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>(jni::alias_ref<jni::JString> /* message */, jni::alias_ref<jni::JString> /* imagePath */)>("sendMessageWithImage");
+  std::shared_ptr<Promise<std::string>> JHybridLiteRTLMSpec::sendMessageWithImage(const std::string& message, const std::string& imagePath) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* message */, jni::alias_ref<jni::JString> /* imagePath */)>("sendMessageWithImage");
     auto __result = method(_javaPart, jni::make_jstring(message), jni::make_jstring(imagePath));
-    return __result->toStdString();
+    return [&]() {
+      auto __promise = Promise<std::string>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JString>(__boxedResult);
+        __promise->resolve(__result->toStdString());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
   }
-  std::string JHybridLiteRTLMSpec::sendMessageWithAudio(const std::string& message, const std::string& audioPath) {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>(jni::alias_ref<jni::JString> /* message */, jni::alias_ref<jni::JString> /* audioPath */)>("sendMessageWithAudio");
+  std::shared_ptr<Promise<std::string>> JHybridLiteRTLMSpec::sendMessageWithAudio(const std::string& message, const std::string& audioPath) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* message */, jni::alias_ref<jni::JString> /* audioPath */)>("sendMessageWithAudio");
     auto __result = method(_javaPart, jni::make_jstring(message), jni::make_jstring(audioPath));
-    return __result->toStdString();
+    return [&]() {
+      auto __promise = Promise<std::string>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JString>(__boxedResult);
+        __promise->resolve(__result->toStdString());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
   }
   void JHybridLiteRTLMSpec::sendMessageAsync(const std::string& message, const std::function<void(const std::string& /* token */, bool /* done */)>& onToken) {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* message */, jni::alias_ref<JFunc_void_std__string_bool::javaobject> /* onToken */)>("sendMessageAsync_cxx");

package/nitrogen/generated/android/c++/JHybridLiteRTLMSpec.hpp

@@ -55,10 +55,10 @@ namespace margelo::nitro::litertlm {
 
   public:
     // Methods
-    void loadModel(const std::string& modelPath, const std::optional<LLMConfig>& config) override;
-    std::string sendMessage(const std::string& message) override;
-    std::string sendMessageWithImage(const std::string& message, const std::string& imagePath) override;
-    std::string sendMessageWithAudio(const std::string& message, const std::string& audioPath) override;
+    std::shared_ptr<Promise<void>> loadModel(const std::string& modelPath, const std::optional<LLMConfig>& config) override;
+    std::shared_ptr<Promise<std::string>> sendMessage(const std::string& message) override;
+    std::shared_ptr<Promise<std::string>> sendMessageWithImage(const std::string& message, const std::string& imagePath) override;
+    std::shared_ptr<Promise<std::string>> sendMessageWithAudio(const std::string& message, const std::string& audioPath) override;
     void sendMessageAsync(const std::string& message, const std::function<void(const std::string& /* token */, bool /* done */)>& onToken) override;
     std::vector<Message> getHistory() override;
     void resetConversation() override;

package/nitrogen/generated/android/kotlin/com/margelo/nitro/dev/litert/litertlm/HybridLiteRTLMSpec.kt

@@ -10,6 +10,7 @@ package com.margelo.nitro.dev.litert.litertlm
 import androidx.annotation.Keep
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.Promise
 import com.margelo.nitro.core.HybridObject
 
 /**
@@ -47,19 +48,19 @@ abstract class HybridLiteRTLMSpec: HybridObject() {
   // Methods
   @DoNotStrip
   @Keep
-  abstract fun loadModel(modelPath: String, config: LLMConfig?): Unit
+  abstract fun loadModel(modelPath: String, config: LLMConfig?): Promise<Unit>
   
   @DoNotStrip
   @Keep
-  abstract fun sendMessage(message: String): String
+  abstract fun sendMessage(message: String): Promise<String>
   
   @DoNotStrip
   @Keep
-  abstract fun sendMessageWithImage(message: String, imagePath: String): String
+  abstract fun sendMessageWithImage(message: String, imagePath: String): Promise<String>
   
   @DoNotStrip
   @Keep
-  abstract fun sendMessageWithAudio(message: String, audioPath: String): String
+  abstract fun sendMessageWithAudio(message: String, audioPath: String): Promise<String>
   
   abstract fun sendMessageAsync(message: String, onToken: (token: String, done: Boolean) -> Unit): Unit
   

package/nitrogen/generated/shared/c++/HybridLiteRTLMSpec.hpp

@@ -20,6 +20,7 @@ namespace margelo::nitro::litertlm { struct Message; }
 // Forward declaration of `GenerationStats` to properly resolve imports.
 namespace margelo::nitro::litertlm { struct GenerationStats; }
 
+#include <NitroModules/Promise.hpp>
 #include <string>
 #include "LLMConfig.hpp"
 #include <optional>
@@ -59,10 +60,10 @@ namespace margelo::nitro::litertlm {
 
     public:
       // Methods
-      virtual void loadModel(const std::string& modelPath, const std::optional<LLMConfig>& config) = 0;
-      virtual std::string sendMessage(const std::string& message) = 0;
-      virtual std::string sendMessageWithImage(const std::string& message, const std::string& imagePath) = 0;
-      virtual std::string sendMessageWithAudio(const std::string& message, const std::string& audioPath) = 0;
+      virtual std::shared_ptr<Promise<void>> loadModel(const std::string& modelPath, const std::optional<LLMConfig>& config) = 0;
+      virtual std::shared_ptr<Promise<std::string>> sendMessage(const std::string& message) = 0;
+      virtual std::shared_ptr<Promise<std::string>> sendMessageWithImage(const std::string& message, const std::string& imagePath) = 0;
+      virtual std::shared_ptr<Promise<std::string>> sendMessageWithAudio(const std::string& message, const std::string& audioPath) = 0;
       virtual void sendMessageAsync(const std::string& message, const std::function<void(const std::string& /* token */, bool /* done */)>& onToken) = 0;
       virtual std::vector<Message> getHistory() = 0;
       virtual void resetConversation() = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-litert-lm",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "High-performance LLM inference for React Native using LiteRT-LM. Optimized for Gemma 3n and other on-device language models.",
   "license": "MIT",
   "author": "Hugh Chen (https://github.com/hung-yueh)",

package/src/specs/LiteRTLM.nitro.ts

@@ -118,18 +118,17 @@ export interface LiteRTLM extends HybridObject<{
 }> {
   /**
    * Load a .litertlm model file.
-   * @param modelPath Absolute path to the .litertlm file.
    * @param config Optional configuration for backend and sampling.
    * @throws Error if the model cannot be loaded.
    */
-  loadModel(modelPath: string, config?: LLMConfig): void;
+  loadModel(modelPath: string, config?: LLMConfig): Promise<void>;
 
   /**
    * Send a text message and get the complete response (blocking).
    * @param message User message text.
    * @returns The model's response text.
    */
-  sendMessage(message: string): string;
+  sendMessage(message: string): Promise<string>;
 
   /**
    * Send a text message with an image (multimodal).
@@ -137,7 +136,7 @@ export interface LiteRTLM extends HybridObject<{
    * @param imagePath Absolute path to an image file.
    * @returns The model's response text.
    */
-  sendMessageWithImage(message: string, imagePath: string): string;
+  sendMessageWithImage(message: string, imagePath: string): Promise<string>;
 
   /**
    * Send a text message with audio (multimodal).
@@ -145,7 +144,7 @@ export interface LiteRTLM extends HybridObject<{
    * @param audioPath Absolute path to an audio file (WAV).
    * @returns The model's response text.
    */
-  sendMessageWithAudio(message: string, audioPath: string): string;
+  sendMessageWithAudio(message: string, audioPath: string): Promise<string>;
 
   /**
    * Send a message with streaming response.