@dr33m/react-native-litert-lm 0.6.1 → 0.6.3

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

@@ -728,6 +728,9 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
      * held and believed in.
      */
     fun releaseUnderMemoryPressure() {
+        // Nothing loaded is nothing to free, and saying otherwise turns one
+        // emergency into a page of identical warnings.
+        if (engine == null) return
         Log.w(TAG, "Releasing engine under memory pressure; instance stays reloadable")
         cleanupInternal()
     }
@@ -736,6 +739,9 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
         Log.d(TAG, "Closing resources")
         isClosed = true
         cleanupInternal()
+        // A closed instance can never load again, so it has no business being
+        // woken by the next memory emergency.
+        LiteRTLMRegistry.unregister(this)
     }
 
     private fun cleanupInternal() {
@@ -743,14 +749,36 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
         // for it while holding the lock would block loadModel behind it.
         cancelInFlightGeneration()
         synchronized(initLock) {
+            /*
+             * Dropped first, closed second.
+             *
+             * These used to be nulled after their `close()` calls, inside one
+             * try. A close that threw — and closing a conversation that has
+             * just been cancelled is exactly when one does — skipped the rest
+             * of the block and left a retired engine still referenced. Nothing
+             * downstream could tell: `isReady()` reads `engine != null`, so the
+             * instance went on reporting itself loaded, and the next
+             * `resetConversation()` called `createConversation` on a closed
+             * engine and threw "Engine is not initialized" from deep in the SDK.
+             *
+             * Letting go of the references first makes that impossible: after
+             * this block the instance is unloaded whatever the native side did.
+             */
+            val retiredConversation = conversation
+            val retiredEngine = engine
+            conversation = null
+            engine = null
+            loadedModelPath = null
+
+            try {
+                retiredConversation?.close()
+            } catch (e: Exception) {
+                Log.w(TAG, "Error closing conversation: ${e.message}")
+            }
             try {
-                conversation?.close()
-                conversation = null
-                engine?.close()        // Direct call
-                engine = null 
-                loadedModelPath = null
+                retiredEngine?.close()
             } catch (e: Exception) {
-                Log.e(TAG, "Error closing resources", e)
+                Log.w(TAG, "Error closing engine: ${e.message}")
             }
         }
     }
@@ -819,7 +847,12 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
         //   - Kotlin:   Not yet available — track at https://github.com/google-ai-edge/LiteRT-LM
         //
         // Once the Kotlin SDK exposes this, wire it via ConversationConfig here.
-        conversation = engine!!.createConversation(convConfig)
+        // Checked rather than forced: this runs from `resetConversation`, which
+        // JS calls on paths that do not first ask whether anything is loaded.
+        // A named error beats a null-pointer dereference from inside the SDK.
+        val activeEngine = engine
+            ?: throw RuntimeException("Cannot create a conversation: no model is loaded.")
+        conversation = activeEngine.createConversation(convConfig)
     }
 
 
@@ -960,7 +993,17 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
 
                 val userMsg = LiteRTMessage.user(Contents.of(contents))
 
-                val extraContext: Map<String, String> = if (enableThinking) mapOf("enable_thinking" to "true") else emptyMap()
+                // Always stated, never omitted.
+                //
+                // `enable_thinking` is a chat-template variable, not a Gemma
+                // feature, and templates test it as "defined and false". Qwen3's
+                // is exactly that shape, so leaving the key out is not the same
+                // as setting it to false: undefined falls through to the
+                // template's own default, which for a reasoning model is to
+                // reason. Omitting it meant thinking could be turned on but
+                // never off, and the reasoning arrived inline in the answer.
+                val extraContext: Map<String, String> =
+                    mapOf("enable_thinking" to enableThinking.toString())
 
                 if (onToken != null) {
                     // ── Streaming path ────────────────────────────────────────────────

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

@@ -21,6 +21,23 @@ object LiteRTLMRegistry {
         }
     }
 
+    /**
+     * Drop a retired instance.
+     *
+     * The set holds weak keys, so a dead instance does leave eventually — but
+     * only once GC gets to it, and until then it is still iterated and still
+     * logged against. Every `loadModel()` mints a fresh HybridLiteRTLM, so a
+     * few reloads were enough for one memory emergency to report five engines
+     * released when only the last of them held anything. Closing is a definite
+     * end, so it is a better moment to forget an instance than a collection
+     * that may not have happened yet.
+     */
+    fun unregister(instance: HybridLiteRTLM) {
+        synchronized(instances) {
+            instances.remove(instance)
+        }
+    }
+
     /**
      * Whether a trim level is a real emergency worth dropping engines for.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dr33m/react-native-litert-lm",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "litertLm": {
     "version": "0.15.0",
     "androidMavenVersion": "0.15.0",