react-native-litert-lm 0.3.7 → 0.4.0

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

@@ -14,6 +14,34 @@ export type Backend = "cpu" | "gpu" | "npu";
  * Message roles for conversation.
  */
 export type Role = "user" | "model" | "system";
+/**
+ * Definition for a function/tool that the model can request to execute.
+ */
+export interface ToolDefinition {
+    /** Name of the function/tool */
+    name: string;
+    /** Human-readable description of what the function/tool does */
+    description: string;
+    /** JSON schema defining parameter names and types (stringified) */
+    parametersJson: string;
+}
+/**
+ * The part type for a multimodal message content part.
+ */
+export type PartType = "text" | "image" | "audio";
+/**
+ * A part of a unified multimodal message payload.
+ */
+export interface MultimodalPart {
+    /** The part type: 'text', 'image', or 'audio' */
+    type: PartType;
+    /** The plain text content, if type is 'text' */
+    text?: string;
+    /** Raw image binary data, if type is 'image' (zero-copy ArrayBuffer mapping) */
+    imageBuffer?: ArrayBuffer;
+    /** Raw audio binary data, if type is 'audio' (zero-copy ArrayBuffer mapping) */
+    audioBuffer?: ArrayBuffer;
+}
 /**
  * Configuration options for loading an LLM.
  */
@@ -60,6 +88,37 @@ export interface LLMConfig {
      * @default 0.95
      */
     topP?: number;
+    /**
+     * Whether to run engine validation after loading the model.
+     * When enabled, sends a quick test inference ("Hi") and waits up to 30s
+     * for a response to confirm the backend works. This is useful for GPU/NPU
+     * backends that may silently fail during inference (they can initialize
+     * without error but produce no tokens).
+     *
+     * Validation is **always a no-op on CPU** — the CPU backend is inherently
+     * reliable and never needs validation.
+     *
+     * Disabled by default because it adds significant latency (5-30s) to model loading.
+     * Enable only to catch GPU/NPU silent failure issues during development.
+     *
+     * @default false
+     */
+    validate?: boolean;
+    /**
+     * Whether this is a multimodal model.
+     * When enabled, the engine handles image/audio tokens properly.
+     * If not specified, the system will fall back to filename sniffing.
+     */
+    multimodal?: boolean;
+    /**
+     * List of tools/functions that the model can call.
+     */
+    tools?: ToolDefinition[];
+    /**
+     * Whether to enable speculative decoding (multi-token prediction) if supported by the model.
+     * @default false
+     */
+    enableSpeculativeDecoding?: boolean;
 }
 /**
  * A simple message in the conversation.
@@ -123,7 +182,7 @@ export interface MemoryUsage {
  * ```
  */
 export interface LiteRTLM extends HybridObject<{
-    ios: "c++";
+    ios: "swift";
     android: "kotlin";
 }> {
     /**
@@ -165,13 +224,19 @@ export interface LiteRTLM extends HybridObject<{
      * @returns The model's response text.
      */
     sendMessageWithAudio(message: string, audioPath: string): Promise<string>;
+    /**
+     * Send a unified multimodal message containing text and/or zero-copy binary buffers.
+     * @param parts The message content parts (text, image, and/or audio).
+     * @returns The model's response text.
+     */
+    sendMultimodalMessage(parts: MultimodalPart[]): Promise<string>;
     /**
      * Send a message with streaming response.
      * Tokens are delivered via callback as they are generated.
      * @param message User message text.
      * @param onToken Callback invoked for each token (token, isDone).
      */
-    sendMessageAsync(message: string, onToken: (token: string, done: boolean) => void): void;
+    sendMessageAsync(message: string, onToken: (token: string, done: boolean) => void): Promise<void>;
     /**
      * Get the current conversation history.
      * @returns Array of messages in the conversation.
@@ -189,6 +254,10 @@ export interface LiteRTLM extends HybridObject<{
      * Get the last generation statistics.
      */
     getStats(): GenerationStats;
+    /**
+     * Count tokens in a text string. Returns -1 if unavailable.
+     */
+    countTokens(text: string): number;
     /**
      * Get real memory usage from the native runtime.
      * Uses OS-level APIs to report actual memory consumption.

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

@@ -19,6 +19,12 @@ namespace margelo::nitro::litertlm { struct MemoryUsage; }
 namespace margelo::nitro::litertlm { struct LLMConfig; }
 // Forward declaration of `Backend` to properly resolve imports.
 namespace margelo::nitro::litertlm { enum class Backend; }
+// Forward declaration of `ToolDefinition` to properly resolve imports.
+namespace margelo::nitro::litertlm { struct ToolDefinition; }
+// Forward declaration of `MultimodalPart` to properly resolve imports.
+namespace margelo::nitro::litertlm { struct MultimodalPart; }
+// Forward declaration of `PartType` to properly resolve imports.
+namespace margelo::nitro::litertlm { enum class PartType; }
 
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/JPromise.hpp>
@@ -38,9 +44,17 @@ namespace margelo::nitro::litertlm { enum class Backend; }
 #include "JLLMConfig.hpp"
 #include "Backend.hpp"
 #include "JBackend.hpp"
+#include "ToolDefinition.hpp"
+#include "JToolDefinition.hpp"
 #include <functional>
 #include "JFunc_void_double.hpp"
 #include <NitroModules/JNICallable.hpp>
+#include "MultimodalPart.hpp"
+#include "JMultimodalPart.hpp"
+#include "PartType.hpp"
+#include "JPartType.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/JArrayBuffer.hpp>
 #include "JFunc_void_std__string_bool.hpp"
 
 namespace margelo::nitro::litertlm {
@@ -170,23 +184,59 @@ namespace margelo::nitro::litertlm {
       return __promise;
     }();
   }
-  void JHybridLiteRTLMSpec::sendMessageAsync(const std::string& message, const std::function<void(const std::string& /* token */, bool /* done */)>& onToken) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* message */, jni::alias_ref<JFunc_void_std__string_bool::javaobject> /* onToken */)>("sendMessageAsync_cxx");
-    method(_javaPart, jni::make_jstring(message), JFunc_void_std__string_bool_cxx::fromCpp(onToken));
+  std::shared_ptr<Promise<std::string>> JHybridLiteRTLMSpec::sendMultimodalMessage(const std::vector<MultimodalPart>& parts) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JArrayClass<JMultimodalPart>> /* parts */)>("sendMultimodalMessage");
+    auto __result = method(_javaPart, [&](auto&& __input) {
+      size_t __size = __input.size();
+      jni::local_ref<jni::JArrayClass<JMultimodalPart>> __array = jni::JArrayClass<JMultimodalPart>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = __input[__i];
+        auto __elementJni = JMultimodalPart::fromCpp(__element);
+        __array->setElement(__i, *__elementJni);
+      }
+      return __array;
+    }(parts));
+    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::shared_ptr<Promise<void>> JHybridLiteRTLMSpec::sendMessageAsync(const std::string& message, const std::function<void(const std::string& /* token */, bool /* done */)>& onToken) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* message */, jni::alias_ref<JFunc_void_std__string_bool::javaobject> /* onToken */)>("sendMessageAsync_cxx");
+    auto __result = method(_javaPart, jni::make_jstring(message), JFunc_void_std__string_bool_cxx::fromCpp(onToken));
+    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::vector<Message> JHybridLiteRTLMSpec::getHistory() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JMessage>>()>("getHistory");
     auto __result = method(_javaPart);
-    return [&]() {
-      size_t __size = __result->size();
+    return [&](auto&& __input) {
+      size_t __size = __input->size();
       std::vector<Message> __vector;
       __vector.reserve(__size);
       for (size_t __i = 0; __i < __size; __i++) {
-        auto __element = __result->getElement(__i);
+        auto __element = __input->getElement(__i);
         __vector.push_back(__element->toCpp());
       }
       return __vector;
-    }();
+    }(__result);
   }
   void JHybridLiteRTLMSpec::resetConversation() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("resetConversation");
@@ -202,6 +252,11 @@ namespace margelo::nitro::litertlm {
     auto __result = method(_javaPart);
     return __result->toCpp();
   }
+  double JHybridLiteRTLMSpec::countTokens(const std::string& text) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<double(jni::alias_ref<jni::JString> /* text */)>("countTokens");
+    auto __result = method(_javaPart, jni::make_jstring(text));
+    return __result;
+  }
   MemoryUsage JHybridLiteRTLMSpec::getMemoryUsage() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JMemoryUsage>()>("getMemoryUsage");
     auto __result = method(_javaPart);

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

@@ -60,11 +60,13 @@ namespace margelo::nitro::litertlm {
     std::shared_ptr<Promise<std::string>> downloadModel(const std::string& url, const std::string& fileName, const std::optional<std::function<void(double /* progress */)>>& onProgress) override;
     std::shared_ptr<Promise<void>> deleteModel(const std::string& fileName) 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::shared_ptr<Promise<std::string>> sendMultimodalMessage(const std::vector<MultimodalPart>& parts) override;
+    std::shared_ptr<Promise<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;
     bool isReady() override;
     GenerationStats getStats() override;
+    double countTokens(const std::string& text) override;
     MemoryUsage getMemoryUsage() override;
     void close() override;
 

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

@@ -12,8 +12,11 @@
 
 #include "Backend.hpp"
 #include "JBackend.hpp"
+#include "JToolDefinition.hpp"
+#include "ToolDefinition.hpp"
 #include <optional>
 #include <string>
+#include <vector>
 
 namespace margelo::nitro::litertlm {
 
@@ -46,13 +49,34 @@ namespace margelo::nitro::litertlm {
       jni::local_ref<jni::JDouble> topK = this->getFieldValue(fieldTopK);
       static const auto fieldTopP = clazz->getField<jni::JDouble>("topP");
       jni::local_ref<jni::JDouble> topP = this->getFieldValue(fieldTopP);
+      static const auto fieldValidate = clazz->getField<jni::JBoolean>("validate");
+      jni::local_ref<jni::JBoolean> validate = this->getFieldValue(fieldValidate);
+      static const auto fieldMultimodal = clazz->getField<jni::JBoolean>("multimodal");
+      jni::local_ref<jni::JBoolean> multimodal = this->getFieldValue(fieldMultimodal);
+      static const auto fieldTools = clazz->getField<jni::JArrayClass<JToolDefinition>>("tools");
+      jni::local_ref<jni::JArrayClass<JToolDefinition>> tools = this->getFieldValue(fieldTools);
+      static const auto fieldEnableSpeculativeDecoding = clazz->getField<jni::JBoolean>("enableSpeculativeDecoding");
+      jni::local_ref<jni::JBoolean> enableSpeculativeDecoding = this->getFieldValue(fieldEnableSpeculativeDecoding);
       return LLMConfig(
         systemPrompt != nullptr ? std::make_optional(systemPrompt->toStdString()) : std::nullopt,
         backend != nullptr ? std::make_optional(backend->toCpp()) : std::nullopt,
         maxTokens != nullptr ? std::make_optional(maxTokens->value()) : std::nullopt,
         temperature != nullptr ? std::make_optional(temperature->value()) : std::nullopt,
         topK != nullptr ? std::make_optional(topK->value()) : std::nullopt,
-        topP != nullptr ? std::make_optional(topP->value()) : std::nullopt
+        topP != nullptr ? std::make_optional(topP->value()) : std::nullopt,
+        validate != nullptr ? std::make_optional(static_cast<bool>(validate->value())) : std::nullopt,
+        multimodal != nullptr ? std::make_optional(static_cast<bool>(multimodal->value())) : std::nullopt,
+        tools != nullptr ? std::make_optional([&](auto&& __input) {
+          size_t __size = __input->size();
+          std::vector<ToolDefinition> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = __input->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }(tools)) : std::nullopt,
+        enableSpeculativeDecoding != nullptr ? std::make_optional(static_cast<bool>(enableSpeculativeDecoding->value())) : std::nullopt
       );
     }
 
@@ -62,7 +86,7 @@ namespace margelo::nitro::litertlm {
      */
     [[maybe_unused]]
     static jni::local_ref<JLLMConfig::javaobject> fromCpp(const LLMConfig& value) {
-      using JSignature = JLLMConfig(jni::alias_ref<jni::JString>, jni::alias_ref<JBackend>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>);
+      using JSignature = JLLMConfig(jni::alias_ref<jni::JString>, jni::alias_ref<JBackend>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JArrayClass<JToolDefinition>>, jni::alias_ref<jni::JBoolean>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
@@ -72,7 +96,20 @@ namespace margelo::nitro::litertlm {
         value.maxTokens.has_value() ? jni::JDouble::valueOf(value.maxTokens.value()) : nullptr,
         value.temperature.has_value() ? jni::JDouble::valueOf(value.temperature.value()) : nullptr,
         value.topK.has_value() ? jni::JDouble::valueOf(value.topK.value()) : nullptr,
-        value.topP.has_value() ? jni::JDouble::valueOf(value.topP.value()) : nullptr
+        value.topP.has_value() ? jni::JDouble::valueOf(value.topP.value()) : nullptr,
+        value.validate.has_value() ? jni::JBoolean::valueOf(value.validate.value()) : nullptr,
+        value.multimodal.has_value() ? jni::JBoolean::valueOf(value.multimodal.value()) : nullptr,
+        value.tools.has_value() ? [&](auto&& __input) {
+          size_t __size = __input.size();
+          jni::local_ref<jni::JArrayClass<JToolDefinition>> __array = jni::JArrayClass<JToolDefinition>::newArray(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            const auto& __element = __input[__i];
+            auto __elementJni = JToolDefinition::fromCpp(__element);
+            __array->setElement(__i, *__elementJni);
+          }
+          return __array;
+        }(value.tools.value()) : nullptr,
+        value.enableSpeculativeDecoding.has_value() ? jni::JBoolean::valueOf(value.enableSpeculativeDecoding.value()) : nullptr
       );
     }
   };

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

@@ -0,0 +1,74 @@
+///
+/// JMultimodalPart.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "MultimodalPart.hpp"
+
+#include "JPartType.hpp"
+#include "PartType.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/JArrayBuffer.hpp>
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::litertlm {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "MultimodalPart" and the the Kotlin data class "MultimodalPart".
+   */
+  struct JMultimodalPart final: public jni::JavaClass<JMultimodalPart> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/dev/litert/litertlm/MultimodalPart;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct MultimodalPart by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    MultimodalPart toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldType = clazz->getField<JPartType>("type");
+      jni::local_ref<JPartType> type = this->getFieldValue(fieldType);
+      static const auto fieldText = clazz->getField<jni::JString>("text");
+      jni::local_ref<jni::JString> text = this->getFieldValue(fieldText);
+      static const auto fieldImageBuffer = clazz->getField<JArrayBuffer::javaobject>("imageBuffer");
+      jni::local_ref<JArrayBuffer::javaobject> imageBuffer = this->getFieldValue(fieldImageBuffer);
+      static const auto fieldAudioBuffer = clazz->getField<JArrayBuffer::javaobject>("audioBuffer");
+      jni::local_ref<JArrayBuffer::javaobject> audioBuffer = this->getFieldValue(fieldAudioBuffer);
+      return MultimodalPart(
+        type->toCpp(),
+        text != nullptr ? std::make_optional(text->toStdString()) : std::nullopt,
+        imageBuffer != nullptr ? std::make_optional(imageBuffer->cthis()->getArrayBuffer()) : std::nullopt,
+        audioBuffer != nullptr ? std::make_optional(audioBuffer->cthis()->getArrayBuffer()) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JMultimodalPart::javaobject> fromCpp(const MultimodalPart& value) {
+      using JSignature = JMultimodalPart(jni::alias_ref<JPartType>, jni::alias_ref<jni::JString>, jni::alias_ref<JArrayBuffer::javaobject>, jni::alias_ref<JArrayBuffer::javaobject>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        JPartType::fromCpp(value.type),
+        value.text.has_value() ? jni::make_jstring(value.text.value()) : nullptr,
+        value.imageBuffer.has_value() ? JArrayBuffer::wrap(value.imageBuffer.value()) : nullptr,
+        value.audioBuffer.has_value() ? JArrayBuffer::wrap(value.audioBuffer.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::litertlm

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

@@ -0,0 +1,61 @@
+///
+/// JPartType.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "PartType.hpp"
+
+namespace margelo::nitro::litertlm {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "PartType" and the the Kotlin enum "PartType".
+   */
+  struct JPartType final: public jni::JavaClass<JPartType> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/dev/litert/litertlm/PartType;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum PartType.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    PartType toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<PartType>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JPartType> fromCpp(PartType value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case PartType::TEXT:
+          static const auto fieldTEXT = clazz->getStaticField<JPartType>("TEXT");
+          return clazz->getStaticFieldValue(fieldTEXT);
+        case PartType::IMAGE:
+          static const auto fieldIMAGE = clazz->getStaticField<JPartType>("IMAGE");
+          return clazz->getStaticFieldValue(fieldIMAGE);
+        case PartType::AUDIO:
+          static const auto fieldAUDIO = clazz->getStaticField<JPartType>("AUDIO");
+          return clazz->getStaticFieldValue(fieldAUDIO);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::litertlm

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

@@ -0,0 +1,65 @@
+///
+/// JToolDefinition.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "ToolDefinition.hpp"
+
+#include <string>
+
+namespace margelo::nitro::litertlm {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "ToolDefinition" and the the Kotlin data class "ToolDefinition".
+   */
+  struct JToolDefinition final: public jni::JavaClass<JToolDefinition> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/dev/litert/litertlm/ToolDefinition;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct ToolDefinition by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ToolDefinition toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldName = clazz->getField<jni::JString>("name");
+      jni::local_ref<jni::JString> name = this->getFieldValue(fieldName);
+      static const auto fieldDescription = clazz->getField<jni::JString>("description");
+      jni::local_ref<jni::JString> description = this->getFieldValue(fieldDescription);
+      static const auto fieldParametersJson = clazz->getField<jni::JString>("parametersJson");
+      jni::local_ref<jni::JString> parametersJson = this->getFieldValue(fieldParametersJson);
+      return ToolDefinition(
+        name->toStdString(),
+        description->toStdString(),
+        parametersJson->toStdString()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JToolDefinition::javaobject> fromCpp(const ToolDefinition& value) {
+      using JSignature = JToolDefinition(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.name),
+        jni::make_jstring(value.description),
+        jni::make_jstring(value.parametersJson)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::litertlm

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

@@ -9,6 +9,7 @@ package com.margelo.nitro.dev.litert.litertlm
 
 import androidx.annotation.Keep
 import com.facebook.proguard.annotations.DoNotStrip
+import java.util.Objects
 
 
 /**
@@ -38,6 +39,28 @@ data class GenerationStats(
 ) {
   /* primary constructor */
 
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is GenerationStats) return false
+    return Objects.deepEquals(this.promptTokens, other.promptTokens)
+      && Objects.deepEquals(this.completionTokens, other.completionTokens)
+      && Objects.deepEquals(this.totalTokens, other.totalTokens)
+      && Objects.deepEquals(this.timeToFirstToken, other.timeToFirstToken)
+      && Objects.deepEquals(this.totalTime, other.totalTime)
+      && Objects.deepEquals(this.tokensPerSecond, other.tokensPerSecond)
+  }
+
+  override fun hashCode(): Int {
+    return arrayOf<Any?>(
+      promptTokens,
+      completionTokens,
+      totalTokens,
+      timeToFirstToken,
+      totalTime,
+      tokensPerSecond
+    ).contentDeepHashCode()
+  }
+
   companion object {
     /**
      * Constructor called from C++

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

@@ -58,11 +58,15 @@ abstract class HybridLiteRTLMSpec: HybridObject() {
   @Keep
   abstract fun sendMessageWithAudio(message: String, audioPath: String): Promise<String>
   
-  abstract fun sendMessageAsync(message: String, onToken: (token: String, done: Boolean) -> Unit): Unit
+  @DoNotStrip
+  @Keep
+  abstract fun sendMultimodalMessage(parts: Array<MultimodalPart>): Promise<String>
+  
+  abstract fun sendMessageAsync(message: String, onToken: (token: String, done: Boolean) -> Unit): Promise<Unit>
   
   @DoNotStrip
   @Keep
-  private fun sendMessageAsync_cxx(message: String, onToken: Func_void_std__string_bool): Unit {
+  private fun sendMessageAsync_cxx(message: String, onToken: Func_void_std__string_bool): Promise<Unit> {
     val __result = sendMessageAsync(message, onToken)
     return __result
   }
@@ -83,6 +87,10 @@ abstract class HybridLiteRTLMSpec: HybridObject() {
   @Keep
   abstract fun getStats(): GenerationStats
   
+  @DoNotStrip
+  @Keep
+  abstract fun countTokens(text: String): Double
+  
   @DoNotStrip
   @Keep
   abstract fun getMemoryUsage(): MemoryUsage

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

@@ -9,6 +9,7 @@ package com.margelo.nitro.dev.litert.litertlm
 
 import androidx.annotation.Keep
 import com.facebook.proguard.annotations.DoNotStrip
+import java.util.Objects
 
 
 /**
@@ -34,10 +35,52 @@ data class LLMConfig(
   val topK: Double?,
   @DoNotStrip
   @Keep
-  val topP: Double?
+  val topP: Double?,
+  @DoNotStrip
+  @Keep
+  val validate: Boolean?,
+  @DoNotStrip
+  @Keep
+  val multimodal: Boolean?,
+  @DoNotStrip
+  @Keep
+  val tools: Array<ToolDefinition>?,
+  @DoNotStrip
+  @Keep
+  val enableSpeculativeDecoding: Boolean?
 ) {
   /* primary constructor */
 
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is LLMConfig) return false
+    return Objects.deepEquals(this.systemPrompt, other.systemPrompt)
+      && Objects.deepEquals(this.backend, other.backend)
+      && Objects.deepEquals(this.maxTokens, other.maxTokens)
+      && Objects.deepEquals(this.temperature, other.temperature)
+      && Objects.deepEquals(this.topK, other.topK)
+      && Objects.deepEquals(this.topP, other.topP)
+      && Objects.deepEquals(this.validate, other.validate)
+      && Objects.deepEquals(this.multimodal, other.multimodal)
+      && Objects.deepEquals(this.tools, other.tools)
+      && Objects.deepEquals(this.enableSpeculativeDecoding, other.enableSpeculativeDecoding)
+  }
+
+  override fun hashCode(): Int {
+    return arrayOf<Any?>(
+      systemPrompt,
+      backend,
+      maxTokens,
+      temperature,
+      topK,
+      topP,
+      validate,
+      multimodal,
+      tools,
+      enableSpeculativeDecoding
+    ).contentDeepHashCode()
+  }
+
   companion object {
     /**
      * Constructor called from C++
@@ -46,8 +89,8 @@ data class LLMConfig(
     @Keep
     @Suppress("unused")
     @JvmStatic
-    private fun fromCpp(systemPrompt: String?, backend: Backend?, maxTokens: Double?, temperature: Double?, topK: Double?, topP: Double?): LLMConfig {
-      return LLMConfig(systemPrompt, backend, maxTokens, temperature, topK, topP)
+    private fun fromCpp(systemPrompt: String?, backend: Backend?, maxTokens: Double?, temperature: Double?, topK: Double?, topP: Double?, validate: Boolean?, multimodal: Boolean?, tools: Array<ToolDefinition>?, enableSpeculativeDecoding: Boolean?): LLMConfig {
+      return LLMConfig(systemPrompt, backend, maxTokens, temperature, topK, topP, validate, multimodal, tools, enableSpeculativeDecoding)
     }
   }
 }