react-native-litert-lm 0.3.4 → 0.3.5

package/README.md

@@ -82,6 +82,8 @@ The `example/` directory contains a fully functional test app with a dark-themed
    npm install
    ```
 
+   > **Important:** Use `npm` (not `pnpm`) for the example app. The library is linked via `file:..`, and npm creates a symlink so the iOS XCFramework is visible to CocoaPods. pnpm copies files based on the `files` array and misses `ios/Frameworks/`.
+
 3. **Create a development build and run:**
 
    ```bash
@@ -452,7 +454,7 @@ const prompt = applyGemmaTemplate(
 | react-native-nitro-modules | 0.35.0+       |
 | Android API                | 26+ (ARM64)   |
 | iOS                        | 15.0+ (ARM64) |
-| LiteRT-LM Engine            | 0.10.1          |
+| LiteRT-LM Engine            | 0.10.2          |
 
 ## Platform Support
 
@@ -491,7 +493,7 @@ Add to your app's `.entitlements` file:
 
 ## Building the iOS Engine
 
-The iOS build uses a **Bazel-to-XCFramework pipeline** that compiles the LiteRT-LM C engine and all transitive dependencies into a static library (~83 MB).
+The iOS build uses a **Bazel-to-XCFramework pipeline** that compiles the LiteRT-LM C engine and all transitive dependencies into a static library (~82–84 MB).
 
 ### Prerequisites
 
@@ -506,12 +508,12 @@ The iOS build uses a **Bazel-to-XCFramework pipeline** that compiles the LiteRT-
 
 This will:
 
-1. Clone/checkout LiteRT-LM `v0.10.1` source into `.litert-lm-build/`
-2. Build `//c:engine` for `ios_arm64` and `ios_sim_arm64` via Bazel
-3. Collect all transitive `.o` files (engine, protobuf, re2, sentencepiece, etc.)
-4. Compile C/C++ stubs for unavailable Rust dependencies
-5. Patch `PromptTemplate` to use a simplified template engine (no Rust MinijinjaTemplate)
-6. Merge ~1,900 object files into a static library via `libtool`
+1. Clone/checkout LiteRT-LM `v0.10.2` source into `.litert-lm-build/`
+2. Apply `scripts/patches/ios-engine-fixes.patch` (PromptTemplate simplification, linker fixes)
+3. Build `//c:engine` for `ios_arm64` and `ios_sim_arm64` via Bazel
+4. Collect all transitive `.o` files (engine, protobuf, re2, sentencepiece, etc.)
+5. Compile C/C++ stubs for unavailable Rust dependencies
+6. Merge ~1,909 object files into a static library via `libtool`
 7. Package into `ios/Frameworks/LiteRTLM.xcframework`
 
 ### Output
@@ -520,10 +522,10 @@ This will:
 ios/Frameworks/LiteRTLM.xcframework/
 ├── Info.plist
 ├── ios-arm64/LiteRTLM.framework/              # Device
-│   ├── LiteRTLM                                # ~81 MB static library
+│   ├── LiteRTLM                                # ~82 MB static library
 │   └── Headers/litert_lm_engine.h
 └── ios-arm64-simulator/LiteRTLM.framework/    # Simulator
-    ├── LiteRTLM                                # ~83 MB static library
+    ├── LiteRTLM                                # ~84 MB static library
     └── Headers/litert_lm_engine.h
 ```
 

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

@@ -171,27 +171,40 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
                         else -> com.google.ai.edge.litertlm.Backend.CPU()
                     }
                     
-                    // Vision backend: hardcoded to GPU (required by Gemma models)
-                    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()
+                    // Detect multimodal support from model filename.
+                    // Only Gemma 3n bundles vision/audio executors; Gemma 4 E2B is text-only.
+                    // Passing vision/audio backends to a text-only model causes
+                    // vision_litert_compiled_model_executor init failures.
+                    val modelFileName = modelPath.substringAfterLast("/").lowercase()
+                    val isMultimodal = modelFileName.contains("3n") || modelFileName.contains("gemma3")
     
-                    Log.i(TAG, "Backend config: main=$lmBackend, vision=$lmVisionBackend (hardcoded), audio=$lmAudioBackend (hardcoded)")
+                    val lmVisionBackend = if (isMultimodal) com.google.ai.edge.litertlm.Backend.GPU() else null
+                    val lmAudioBackend = if (isMultimodal) com.google.ai.edge.litertlm.Backend.CPU() else null
+    
+                    Log.i(TAG, "Backend config: main=$lmBackend, vision=$lmVisionBackend, audio=$lmAudioBackend, multimodal=$isMultimodal")
     
                     // 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
-                    )
+                    // Create Engine configuration — visionBackend/audioBackend are optional
+                    val engineConfig = if (isMultimodal) {
+                        EngineConfig(
+                            modelPath = modelPath,
+                            backend = lmBackend,
+                            visionBackend = lmVisionBackend!!,
+                            audioBackend = lmAudioBackend!!,
+                            maxNumTokens = maxTokens,
+                            cacheDir = cacheDirectory
+                        )
+                    } else {
+                        EngineConfig(
+                            modelPath = modelPath,
+                            backend = lmBackend,
+                            maxNumTokens = maxTokens,
+                            cacheDir = cacheDirectory
+                        )
+                    }
     
                     if (isClosed) return@synchronized
                     
@@ -615,7 +628,19 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
 
     private fun createNewConversation() {
         ensureLoaded()
-        // Dispose old conversation if needed
+        // v0.10.2 enforces single-session: close existing conversation first
+        conversation?.let { oldConv ->
+            try {
+                if (oldConv is AutoCloseable) {
+                    oldConv.close()
+                } else {
+                    oldConv.javaClass.getMethod("close").invoke(oldConv)
+                }
+            } catch (e: Exception) {
+                Log.w(TAG, "Failed to close old conversation: ${e.message}")
+            }
+            conversation = null
+        }
         conversation = engine!!.createConversation()
         // Apply system prompt/instruction if set
         systemPrompt?.let { prompt ->

package/cpp/HybridLiteRTLM.cpp

@@ -366,12 +366,7 @@ void HybridLiteRTLM::loadModelInternal(
     } else {
       diag += ", Readable: NO (errno: " + std::to_string(errno) + ")";
     }
-    
-    // Get the native error from the C API
-    const char* nativeErr = litert_lm_get_last_error();
-    if (nativeErr && nativeErr[0] != '\0') {
-      diag += " | Native error: " + std::string(nativeErr);
-    }
+
 
     throw std::runtime_error(
       "Failed to create LiteRT-LM engine. Tried backend '" +
@@ -602,12 +597,7 @@ std::string HybridLiteRTLM::sendMessageWithImageInternal(
     conversation_, msgJson.c_str(), nullptr);
   
   if (!response) {
-    std::string errMsg = "LiteRT-LM: sendMessageWithImage failed";
-    const char* nativeErr = litert_lm_get_last_error();
-    if (nativeErr && nativeErr[0] != '\0') {
-      errMsg += ": " + std::string(nativeErr);
-    }
-    throw std::runtime_error(errMsg);
+    throw std::runtime_error("LiteRT-LM: sendMessageWithImage failed");
   }
   
   const char* responseStr = litert_lm_json_response_get_string(response);
@@ -667,12 +657,7 @@ std::string HybridLiteRTLM::sendMessageWithAudioInternal(
     conversation_, msgJson.c_str(), nullptr);
   
   if (!response) {
-    std::string errMsg = "LiteRT-LM: sendMessageWithAudio failed";
-    const char* nativeErr = litert_lm_get_last_error();
-    if (nativeErr && nativeErr[0] != '\0') {
-      errMsg += ": " + std::string(nativeErr);
-    }
-    throw std::runtime_error(errMsg);
+    throw std::runtime_error("LiteRT-LM: sendMessageWithAudio failed");
   }
   
   const char* responseStr = litert_lm_json_response_get_string(response);

package/cpp/include/litert_lm_engine.h

@@ -182,6 +182,15 @@ LITERT_LM_C_API_EXPORT
 void litert_lm_engine_settings_set_max_num_tokens(
     LiteRtLmEngineSettings* settings, int max_num_tokens);
 
+// Sets whether the engine should load different sections of the litertlm file
+// in parallel. Defaults to true.
+//
+// @param settings The engine settings.
+// @param parallel_file_section_loading Whether to load in parallel.
+LITERT_LM_C_API_EXPORT
+void litert_lm_engine_settings_set_parallel_file_section_loading(
+    LiteRtLmEngineSettings* settings, bool parallel_file_section_loading);
+
 // Sets the cache directory for the engine.
 //
 // @param settings The engine settings.
@@ -236,14 +245,12 @@ void litert_lm_engine_settings_set_num_decode_tokens(
 // Returns an empty string if no error has occurred.
 // The returned pointer is valid until the next C API call on the same thread.
 LITERT_LM_C_API_EXPORT
-const char* litert_lm_get_last_error();
 
 // Creates a LiteRT LM Engine from the given settings. The caller is responsible
 // for destroying the engine using `litert_lm_engine_delete`.
 //
 // @param settings The engine settings.
 // @return A pointer to the created engine, or NULL on failure.
-//         Call litert_lm_get_last_error() for details on failure.
 LITERT_LM_C_API_EXPORT
 LiteRtLmEngine* litert_lm_engine_create(const LiteRtLmEngineSettings* settings);
 

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "react-native-litert-lm",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "litertLm": {
-    "version": "0.10.1",
-    "androidMavenVersion": "0.10.0",
-    "iosGitTag": "v0.10.1"
+    "version": "0.10.2",
+    "androidMavenVersion": "0.10.2",
+    "iosGitTag": "v0.10.2"
   },
   "description": "High-performance LLM inference for React Native using LiteRT-LM. Optimized for Gemma 4 and other on-device language models.",
   "license": "MIT",

package/scripts/build-ios-engine.sh

@@ -267,7 +267,7 @@ for ARCH_NAME in "device" "simulator"; do
   <key>CFBundlePackageType</key>
   <string>FMWK</string>
   <key>CFBundleShortVersionString</key>
-  <string>0.9.0</string>
+  <string>0.10.2</string>
   <key>CFBundleVersion</key>
   <string>1</string>
   <key>MinimumOSVersion</key>

package/ios/LiteRTLMAutolinking.mm

@@ -1,30 +0,0 @@
-///
-/// LiteRTLMAutolinking.mm
-/// Registers the C++ HybridLiteRTLM implementation with NitroModules on iOS.
-///
-/// On iOS, there's no JNI_OnLoad equivalent, so we use ObjC +load to register
-/// the HybridObject factory before JS tries to create it.
-///
-
-#import <Foundation/Foundation.h>
-#include <NitroModules/HybridObjectRegistry.hpp>
-#include "HybridLiteRTLM.hpp"
-
-@interface LiteRTLMAutolinking : NSObject
-@end
-
-@implementation LiteRTLMAutolinking
-
-+ (void)load {
-  using namespace margelo::nitro;
-  using namespace margelo::nitro::litertlm;
-  
-  HybridObjectRegistry::registerHybridObjectConstructor(
-    "LiteRTLM",
-    []() -> std::shared_ptr<HybridObject> {
-      return std::make_shared<HybridLiteRTLM>();
-    }
-  );
-}
-
-@end