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

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

@@ -800,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 {
@@ -812,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)
@@ -834,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,
@@ -1023,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 {
@@ -1061,6 +1070,7 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
                         .joinToString("") { it.text }
 
                     val thinkingText = responseMsg.channels["thought"] ?: ""
+                    captureToolCalls(responseMsg.toolCalls)
 
                     history.add(Message(Role.MODEL, response))
 
@@ -1094,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/ios/HybridLiteRTLM.swift

@@ -431,15 +431,16 @@ public class HybridLiteRTLM: HybridLiteRTLMSpec_base, HybridLiteRTLMSpec_protoco
         
         litert_lm_session_config_set_max_output_tokens(sessionConfig, Int32(self.maxOutputTokens))
         
-        var sampler = LiteRtLmSamplerParams()
-        sampler.type = kLiteRtLmSamplerTypeTopP
-        sampler.top_k = Int32(self.topK)
-        sampler.top_p = Float(self.topP)
-        sampler.temperature = Float(self.temperature)
-        sampler.seed = 0
-        withUnsafePointer(to: &sampler) { samplerPtr in
-            litert_lm_session_config_set_sampler_params(sessionConfig, samplerPtr)
-        }
+        // v0.15: sampler params are opaque — built through create/setters
+        // instead of a stack struct. set_sampler_params copies the values into
+        // the session config, so the params can be freed when this scope ends.
+        guard let sampler = litert_lm_sampler_params_create(kLiteRtLmSamplerTypeTopP) else { return }
+        defer { litert_lm_sampler_params_delete(sampler) }
+        litert_lm_sampler_params_set_top_k(sampler, Int32(self.topK))
+        litert_lm_sampler_params_set_top_p(sampler, Float(self.topP))
+        litert_lm_sampler_params_set_temperature(sampler, Float(self.temperature))
+        litert_lm_sampler_params_set_seed(sampler, 0)
+        litert_lm_session_config_set_sampler_params(sessionConfig, sampler)
         
         litert_lm_conversation_config_set_session_config(convConfig, sessionConfig)
         

package/package.json

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