@dr33m/react-native-litert-lm 0.6.2 → 0.6.4

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

@@ -749,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}")
             }
         }
     }
@@ -778,7 +800,7 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
             }
             conversation = null
         }
-        // Map tools — capture tool calls for JS instead of executing natively
+        // Map tools. The engine only parses calls; JS runs them (see `automaticToolCalling`).
         val lmTools: List<ToolProvider>? = tools?.map { toolDef ->
             val apiTool = object : OpenApiTool {
                 override fun getToolDescriptionJsonString(): String {
@@ -790,12 +812,9 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
                     return fullDesc.toString()
                 }
                 override fun execute(paramsJsonString: String): String {
-                    Log.d(TAG, "Tool called: ${toolDef.name} with args: $paramsJsonString")
-                    pendingToolCalls.add(ToolCall(
-                        name = toolDef.name,
-                        argumentsJson = paramsJsonString
-                    ))
-                    return "{\"status\": \"pending\", \"message\": \"Tool execution delegated to application\"}"
+                    // Never invoked: automatic tool calling is off, so tool
+                    // execution happens on the JS side.
+                    return "{}"
                 }
             }
             tool(apiTool)
@@ -812,6 +831,17 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
             systemInstruction = systemPrompt?.let { Contents.of(Content.Text(it)) },
             initialMessages = initialMessages,
             tools = lmTools ?: emptyList(),
+            /*
+             * Off, ported from upstream (hung-yueh 2cc938a). The SDK default runs
+             * each parsed call against `execute()` above, which was a stub, and
+             * feeds that stub's reply straight back to the model in the same
+             * turn. The model then answered the stub: prose claiming a result it
+             * never had ("I have removed it…"), streamed to the reader, then
+             * discarded once JS ran the real tool and generated again. A wasted
+             * generation per call, and its tokens stayed in the KV cache.
+             * With it off, calls arrive on `Message.toolCalls` instead.
+             */
+            automaticToolCalling = false,
             // Available since LiteRT-LM 0.15.0; before that the Kotlin SDK had no
             // way to express it and every Android reply ran to the engine default.
             maxOutputToken = maxOutputTokens,
@@ -825,7 +855,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)
     }
 
 
@@ -996,7 +1031,8 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
                         history = history,
                         userMessage = userTextRepresentation,
                         onStatsReady = { stats -> lastStats = stats },
-                        onFailure = { e -> errorRef.set(e) }
+                        onFailure = { e -> errorRef.set(e) },
+                        onToolCalls = { calls -> captureToolCalls(calls) }
                     )
 
                     try {
@@ -1034,6 +1070,7 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
                         .joinToString("") { it.text }
 
                     val thinkingText = responseMsg.channels["thought"] ?: ""
+                    captureToolCalls(responseMsg.toolCalls)
 
                     history.add(Message(Role.MODEL, response))
 
@@ -1067,6 +1104,15 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
         }
     }
 
+    /** Records SDK-parsed calls in the shape JS receives on `ExecuteResult.toolCalls`. */
+    private fun captureToolCalls(calls: List<com.google.ai.edge.litertlm.ToolCall>?) {
+        for (call in calls.orEmpty()) {
+            val argumentsJson = org.json.JSONObject(call.arguments).toString()
+            Log.d(TAG, "Tool called: ${call.name} with args: $argumentsJson")
+            pendingToolCalls.add(ToolCall(name = call.name, argumentsJson = argumentsJson))
+        }
+    }
+
     override fun sendToolResponse(
         responses: Array<ToolResponse>,
         onToken: ((token: String, done: Boolean) -> Unit)?

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

@@ -18,6 +18,8 @@ internal class StreamingCallbackListener(
     private val onStatsReady: (GenerationStats) -> Unit,
     private val onFailure: ((Throwable) -> Unit)? = null,
     private val onThinkingToken: ((String) -> Unit)? = null,
+    /** Tool calls the engine parsed out of this reply. They arrive on the final message. */
+    private val onToolCalls: ((List<com.google.ai.edge.litertlm.ToolCall>) -> Unit)? = null,
 ) : com.google.ai.edge.litertlm.MessageCallback {
 
     private val startTime = System.nanoTime()
@@ -29,6 +31,8 @@ internal class StreamingCallbackListener(
             .filterIsInstance<Content.Text>()
             .joinToString("") { it.text }
 
+        if (message.toolCalls.isNotEmpty()) onToolCalls?.invoke(message.toolCalls)
+
         // Capture thinking from the "thought" channel
         val thinkingChunk = message.channels["thought"]
         if (!thinkingChunk.isNullOrEmpty()) {

package/package.json

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