react-native-litert-lm 0.2.0 → 0.2.2

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

@@ -18,6 +18,12 @@ export type Role = "user" | "model" | "system";
  * Configuration options for loading an LLM.
  */
 export interface LLMConfig {
+    /**
+     * System prompt to set the model's behavior.
+     * This is prepended to the conversation to guide model responses.
+     * @example "You are a helpful coding assistant."
+     */
+    systemPrompt?: string;
     /**
      * Primary compute backend for text generation.
      * - 'cpu': CPU inference (slower but always available)
@@ -82,6 +88,20 @@ export interface GenerationStats {
     /** Tokens per second */
     tokensPerSecond: number;
 }
+/**
+ * Real memory usage statistics from the native runtime.
+ * Measured from OS-level APIs, not estimated.
+ */
+export interface MemoryUsage {
+    /** Native heap allocated bytes (Debug.getNativeHeapAllocatedSize on Android, malloc_size on iOS) */
+    nativeHeapBytes: number;
+    /** Total process resident set size (RSS) in bytes */
+    residentBytes: number;
+    /** Available system memory in bytes */
+    availableMemoryBytes: number;
+    /** Whether the system considers memory low */
+    isLowMemory: boolean;
+}
 /**
  * LiteRT-LM: High-performance LLM inference engine.
  * Supports Gemma 3n, Phi-4, Qwen, and other .litertlm models.
@@ -125,6 +145,19 @@ export interface LiteRTLM extends HybridObject<{
      * @returns The model's response text.
      */
     sendMessageWithImage(message: string, imagePath: string): Promise<string>;
+    /**
+     * Download a model file from a URL.
+     * @param url URL to download from.
+     * @param fileName Filename to save as (in app's files directory).
+     * @param onProgress Callback for download progress (0.0 - 1.0).
+     * @returns Absolute path to the downloaded file.
+     */
+    downloadModel(url: string, fileName: string, onProgress?: (progress: number) => void): Promise<string>;
+    /**
+     * Delete a downloaded model file.
+     * @param fileName Filename to delete (in app's files directory).
+     */
+    deleteModel(fileName: string): Promise<void>;
     /**
      * Send a text message with audio (multimodal).
      * @param message User message text.
@@ -156,6 +189,11 @@ export interface LiteRTLM extends HybridObject<{
      * Get the last generation statistics.
      */
     getStats(): GenerationStats;
+    /**
+     * Get real memory usage from the native runtime.
+     * Uses OS-level APIs to report actual memory consumption.
+     */
+    getMemoryUsage(): MemoryUsage;
     /**
      * Release all native resources.
      * Call this when done with the LLM instance.

package/lib/templates.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Prompt template utilities for different LLM families.
+ *
+ * LiteRT-LM's Conversation API may handle templates internally for some models,
+ * but these utilities give developers explicit control for custom workflows
+ * or when using models with different template formats.
+ *
+ * @example
+ * ```typescript
+ * import { applyGemmaTemplate, ChatMessage } from 'react-native-litert-lm';
+ *
+ * const history: ChatMessage[] = [
+ *   { role: 'user', content: 'What is React Native?' },
+ *   { role: 'model', content: 'React Native is a framework for building...' },
+ *   { role: 'user', content: 'How do I use hooks?' }
+ * ];
+ *
+ * const prompt = applyGemmaTemplate(history, 'You are a helpful coding assistant.');
+ * ```
+ */
+/**
+ * A message in a conversation.
+ */
+export type ChatMessage = {
+    role: "user" | "model" | "system";
+    content: string;
+};
+/**
+ * Apply Gemma chat template (Gemma 2, Gemma 3, Gemma 3n).
+ *
+ * @param history Array of previous messages
+ * @param systemPrompt Optional system prompt
+ * @returns Formatted prompt string
+ */
+export declare function applyGemmaTemplate(history: ChatMessage[], systemPrompt?: string): string;
+/**
+ * Apply Phi chat template (Phi-3, Phi-4).
+ *
+ * @param history Array of previous messages
+ * @param systemPrompt Optional system prompt
+ * @returns Formatted prompt string
+ */
+export declare function applyPhiTemplate(history: ChatMessage[], systemPrompt?: string): string;
+/**
+ * Apply Llama 3 chat template.
+ *
+ * @param history Array of previous messages
+ * @param systemPrompt Optional system prompt
+ * @returns Formatted prompt string
+ */
+export declare function applyLlamaTemplate(history: ChatMessage[], systemPrompt?: string): string;

package/lib/templates.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * Prompt template utilities for different LLM families.
+ *
+ * LiteRT-LM's Conversation API may handle templates internally for some models,
+ * but these utilities give developers explicit control for custom workflows
+ * or when using models with different template formats.
+ *
+ * @example
+ * ```typescript
+ * import { applyGemmaTemplate, ChatMessage } from 'react-native-litert-lm';
+ *
+ * const history: ChatMessage[] = [
+ *   { role: 'user', content: 'What is React Native?' },
+ *   { role: 'model', content: 'React Native is a framework for building...' },
+ *   { role: 'user', content: 'How do I use hooks?' }
+ * ];
+ *
+ * const prompt = applyGemmaTemplate(history, 'You are a helpful coding assistant.');
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyGemmaTemplate = applyGemmaTemplate;
+exports.applyPhiTemplate = applyPhiTemplate;
+exports.applyLlamaTemplate = applyLlamaTemplate;
+/**
+ * Apply Gemma chat template (Gemma 2, Gemma 3, Gemma 3n).
+ *
+ * @param history Array of previous messages
+ * @param systemPrompt Optional system prompt
+ * @returns Formatted prompt string
+ */
+function applyGemmaTemplate(history, systemPrompt) {
+    let result = "";
+    if (systemPrompt) {
+        result += `<start_of_turn>system\n${systemPrompt}<end_of_turn>\n`;
+    }
+    for (const m of history) {
+        result += `<start_of_turn>${m.role}\n${m.content}<end_of_turn>\n`;
+    }
+    result += "<start_of_turn>model\n";
+    return result;
+}
+/**
+ * Apply Phi chat template (Phi-3, Phi-4).
+ *
+ * @param history Array of previous messages
+ * @param systemPrompt Optional system prompt
+ * @returns Formatted prompt string
+ */
+function applyPhiTemplate(history, systemPrompt) {
+    let result = "";
+    if (systemPrompt) {
+        result += `<|system|>\n${systemPrompt}<|end|>\n`;
+    }
+    for (const m of history) {
+        const role = m.role === "model" ? "assistant" : m.role;
+        result += `<|${role}|>\n${m.content}<|end|>\n`;
+    }
+    result += "<|assistant|>\n";
+    return result;
+}
+/**
+ * Apply Llama 3 chat template.
+ *
+ * @param history Array of previous messages
+ * @param systemPrompt Optional system prompt
+ * @returns Formatted prompt string
+ */
+function applyLlamaTemplate(history, systemPrompt) {
+    let result = "<|begin_of_text|>";
+    if (systemPrompt) {
+        result += `<|start_header_id|>system<|end_header_id|>\n\n${systemPrompt}<|eot_id|>`;
+    }
+    for (const m of history) {
+        const role = m.role === "model" ? "assistant" : m.role;
+        result += `<|start_header_id|>${role}<|end_header_id|>\n\n${m.content}<|eot_id|>`;
+    }
+    result += "<|start_header_id|>assistant<|end_header_id|>\n\n";
+    return result;
+}

package/nitrogen/generated/android/LiteRTLMOnLoad.cpp

@@ -16,31 +16,36 @@
 #include <NitroModules/HybridObjectRegistry.hpp>
 
 #include "JHybridLiteRTLMSpec.hpp"
+#include "JFunc_void_double.hpp"
 #include "JFunc_void_std__string_bool.hpp"
 #include <NitroModules/DefaultConstructableObject.hpp>
 
 namespace margelo::nitro::litertlm {
 
 int initialize(JavaVM* vm) {
+  return facebook::jni::initialize(vm, []() {
+    ::margelo::nitro::litertlm::registerAllNatives();
+  });
+}
+
+void registerAllNatives() {
   using namespace margelo::nitro;
   using namespace margelo::nitro::litertlm;
-  using namespace facebook;
-
-  return facebook::jni::initialize(vm, [] {
-    // Register native JNI methods
-    margelo::nitro::litertlm::JHybridLiteRTLMSpec::registerNatives();
-    margelo::nitro::litertlm::JFunc_void_std__string_bool_cxx::registerNatives();
-
-    // Register Nitro Hybrid Objects
-    HybridObjectRegistry::registerHybridObjectConstructor(
-      "LiteRTLM",
-      []() -> std::shared_ptr<HybridObject> {
-        static DefaultConstructableObject<JHybridLiteRTLMSpec::javaobject> object("com/margelo/nitro/dev/litert/litertlm/HybridLiteRTLM");
-        auto instance = object.create();
-        return instance->cthis()->shared();
-      }
-    );
-  });
+
+  // Register native JNI methods
+  margelo::nitro::litertlm::JHybridLiteRTLMSpec::registerNatives();
+  margelo::nitro::litertlm::JFunc_void_double_cxx::registerNatives();
+  margelo::nitro::litertlm::JFunc_void_std__string_bool_cxx::registerNatives();
+
+  // Register Nitro Hybrid Objects
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "LiteRTLM",
+    []() -> std::shared_ptr<HybridObject> {
+      static DefaultConstructableObject<JHybridLiteRTLMSpec::javaobject> object("com/margelo/nitro/dev/litert/litertlm/HybridLiteRTLM");
+      auto instance = object.create();
+      return instance->cthis()->shared();
+    }
+  );
 }
 
 } // namespace margelo::nitro::litertlm

package/nitrogen/generated/android/LiteRTLMOnLoad.hpp

@@ -6,20 +6,29 @@
 ///
 
 #include <jni.h>
+#include <functional>
 #include <NitroModules/NitroDefines.hpp>
 
 namespace margelo::nitro::litertlm {
 
+  [[deprecated("Use registerNatives() instead.")]]
+  int initialize(JavaVM* vm);
+
   /**
-   * Initializes the native (C++) part of LiteRTLM, and autolinks all Hybrid Objects.
-   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`).
+   * Register the native (C++) part of LiteRTLM, and autolinks all Hybrid Objects.
+   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`),
+   * inside a `facebook::jni::initialize(vm, ...)` call.
    * Example:
    * ```cpp (cpp-adapter.cpp)
    * JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
-   *   return margelo::nitro::litertlm::initialize(vm);
+   *   return facebook::jni::initialize(vm, []() {
+   *     // register all LiteRTLM HybridObjects
+   *     margelo::nitro::litertlm::registerNatives();
+   *     // any other custom registrations go here.
+   *   });
    * }
    * ```
    */
-  int initialize(JavaVM* vm);
+  void registerAllNatives();
 
 } // namespace margelo::nitro::litertlm

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

@@ -0,0 +1,75 @@
+///
+/// JFunc_void_double.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 <functional>
+
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::litertlm {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(progress: Double) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_double: public jni::JavaClass<JFunc_void_double> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/dev/litert/litertlm/Func_void_double;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_double` instance holds through JNI.
+     */
+    void invoke(double progress) const {
+      static const auto method = javaClassStatic()->getMethod<void(double /* progress */)>("invoke");
+      method(self(), progress);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_double that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_double_cxx final: public jni::HybridClass<JFunc_void_double_cxx, JFunc_void_double> {
+  public:
+    static jni::local_ref<JFunc_void_double::javaobject> fromCpp(const std::function<void(double /* progress */)>& func) {
+      return JFunc_void_double_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_double_cxx` instance holds.
+     */
+    void invoke_cxx(double progress) {
+      _func(progress);
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(double /* progress */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/dev/litert/litertlm/Func_void_double_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_double_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_double_cxx(const std::function<void(double /* progress */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(double /* progress */)> _func;
+  };
+
+} // namespace margelo::nitro::litertlm

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

@@ -13,6 +13,8 @@ namespace margelo::nitro::litertlm { struct Message; }
 namespace margelo::nitro::litertlm { enum class Role; }
 // Forward declaration of `GenerationStats` to properly resolve imports.
 namespace margelo::nitro::litertlm { struct GenerationStats; }
+// Forward declaration of `MemoryUsage` to properly resolve imports.
+namespace margelo::nitro::litertlm { struct MemoryUsage; }
 // Forward declaration of `LLMConfig` to properly resolve imports.
 namespace margelo::nitro::litertlm { struct LLMConfig; }
 // Forward declaration of `Backend` to properly resolve imports.
@@ -29,14 +31,17 @@ namespace margelo::nitro::litertlm { enum class Backend; }
 #include "JRole.hpp"
 #include "GenerationStats.hpp"
 #include "JGenerationStats.hpp"
+#include "MemoryUsage.hpp"
+#include "JMemoryUsage.hpp"
 #include "LLMConfig.hpp"
 #include <optional>
 #include "JLLMConfig.hpp"
 #include "Backend.hpp"
 #include "JBackend.hpp"
 #include <functional>
-#include "JFunc_void_std__string_bool.hpp"
+#include "JFunc_void_double.hpp"
 #include <NitroModules/JNICallable.hpp>
+#include "JFunc_void_std__string_bool.hpp"
 
 namespace margelo::nitro::litertlm {
 
@@ -124,6 +129,37 @@ namespace margelo::nitro::litertlm {
       return __promise;
     }();
   }
+  std::shared_ptr<Promise<std::string>> JHybridLiteRTLMSpec::downloadModel(const std::string& url, const std::string& fileName, const std::optional<std::function<void(double /* progress */)>>& onProgress) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* url */, jni::alias_ref<jni::JString> /* fileName */, jni::alias_ref<JFunc_void_double::javaobject> /* onProgress */)>("downloadModel_cxx");
+    auto __result = method(_javaPart, jni::make_jstring(url), jni::make_jstring(fileName), onProgress.has_value() ? JFunc_void_double_cxx::fromCpp(onProgress.value()) : nullptr);
+    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::deleteModel(const std::string& fileName) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* fileName */)>("deleteModel");
+    auto __result = method(_javaPart, jni::make_jstring(fileName));
+    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::shared_ptr<Promise<std::string>> JHybridLiteRTLMSpec::sendMessageWithAudio(const std::string& message, const std::string& audioPath) {
     static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* message */, jni::alias_ref<jni::JString> /* audioPath */)>("sendMessageWithAudio");
     auto __result = method(_javaPart, jni::make_jstring(message), jni::make_jstring(audioPath));
@@ -172,6 +208,11 @@ namespace margelo::nitro::litertlm {
     auto __result = method(_javaPart);
     return __result->toCpp();
   }
+  MemoryUsage JHybridLiteRTLMSpec::getMemoryUsage() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JMemoryUsage>()>("getMemoryUsage");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
   void JHybridLiteRTLMSpec::close() {
     static const auto method = javaClassStatic()->getMethod<void()>("close");
     method(_javaPart);

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

@@ -58,12 +58,15 @@ namespace margelo::nitro::litertlm {
     std::shared_ptr<Promise<void>> loadModel(const std::string& modelPath, const std::optional<LLMConfig>& config) override;
     std::shared_ptr<Promise<std::string>> sendMessage(const std::string& message) override;
     std::shared_ptr<Promise<std::string>> sendMessageWithImage(const std::string& message, const std::string& imagePath) override;
+    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::vector<Message> getHistory() override;
     void resetConversation() override;
     bool isReady() override;
     GenerationStats getStats() override;
+    MemoryUsage getMemoryUsage() override;
     void close() override;
 
   private:

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

@@ -13,6 +13,7 @@
 #include "Backend.hpp"
 #include "JBackend.hpp"
 #include <optional>
+#include <string>
 
 namespace margelo::nitro::litertlm {
 
@@ -33,6 +34,8 @@ namespace margelo::nitro::litertlm {
     [[nodiscard]]
     LLMConfig toCpp() const {
       static const auto clazz = javaClassStatic();
+      static const auto fieldSystemPrompt = clazz->getField<jni::JString>("systemPrompt");
+      jni::local_ref<jni::JString> systemPrompt = this->getFieldValue(fieldSystemPrompt);
       static const auto fieldBackend = clazz->getField<JBackend>("backend");
       jni::local_ref<JBackend> backend = this->getFieldValue(fieldBackend);
       static const auto fieldMaxTokens = clazz->getField<jni::JDouble>("maxTokens");
@@ -44,6 +47,7 @@ namespace margelo::nitro::litertlm {
       static const auto fieldTopP = clazz->getField<jni::JDouble>("topP");
       jni::local_ref<jni::JDouble> topP = this->getFieldValue(fieldTopP);
       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,
@@ -58,11 +62,12 @@ namespace margelo::nitro::litertlm {
      */
     [[maybe_unused]]
     static jni::local_ref<JLLMConfig::javaobject> fromCpp(const LLMConfig& value) {
-      using JSignature = JLLMConfig(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>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
         clazz,
+        value.systemPrompt.has_value() ? jni::make_jstring(value.systemPrompt.value()) : nullptr,
         value.backend.has_value() ? JBackend::fromCpp(value.backend.value()) : nullptr,
         value.maxTokens.has_value() ? jni::JDouble::valueOf(value.maxTokens.value()) : nullptr,
         value.temperature.has_value() ? jni::JDouble::valueOf(value.temperature.value()) : nullptr,

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

@@ -0,0 +1,69 @@
+///
+/// JMemoryUsage.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 "MemoryUsage.hpp"
+
+
+
+namespace margelo::nitro::litertlm {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "MemoryUsage" and the the Kotlin data class "MemoryUsage".
+   */
+  struct JMemoryUsage final: public jni::JavaClass<JMemoryUsage> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/dev/litert/litertlm/MemoryUsage;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct MemoryUsage by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    MemoryUsage toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldNativeHeapBytes = clazz->getField<double>("nativeHeapBytes");
+      double nativeHeapBytes = this->getFieldValue(fieldNativeHeapBytes);
+      static const auto fieldResidentBytes = clazz->getField<double>("residentBytes");
+      double residentBytes = this->getFieldValue(fieldResidentBytes);
+      static const auto fieldAvailableMemoryBytes = clazz->getField<double>("availableMemoryBytes");
+      double availableMemoryBytes = this->getFieldValue(fieldAvailableMemoryBytes);
+      static const auto fieldIsLowMemory = clazz->getField<jboolean>("isLowMemory");
+      jboolean isLowMemory = this->getFieldValue(fieldIsLowMemory);
+      return MemoryUsage(
+        nativeHeapBytes,
+        residentBytes,
+        availableMemoryBytes,
+        static_cast<bool>(isLowMemory)
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JMemoryUsage::javaobject> fromCpp(const MemoryUsage& value) {
+      using JSignature = JMemoryUsage(double, double, double, jboolean);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.nativeHeapBytes,
+        value.residentBytes,
+        value.availableMemoryBytes,
+        value.isLowMemory
+      );
+    }
+  };
+
+} // namespace margelo::nitro::litertlm

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

@@ -0,0 +1,80 @@
+///
+/// Func_void_double.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.dev.litert.litertlm
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
+
+
+/**
+ * Represents the JavaScript callback `(progress: number) => void`.
+ * This can be either implemented in C++ (in which case it might be a callback coming from JS),
+ * or in Kotlin/Java (in which case it is a native callback).
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType")
+fun interface Func_void_double: (Double) -> Unit {
+  /**
+   * Call the given JS callback.
+   * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
+   */
+  @DoNotStrip
+  @Keep
+  override fun invoke(progress: Double): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(progress: number) => void`.
+ * This is implemented in C++, via a `std::function<...>`.
+ * The callback might be coming from JS.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "FunctionName",
+  "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName",
+)
+class Func_void_double_cxx: Func_void_double {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(progress: Double): Unit
+    = invoke_cxx(progress)
+
+  @FastNative
+  private external fun invoke_cxx(progress: Double): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(progress: number) => void`.
+ * This is implemented in Java/Kotlin, via a `(Double) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_double_java(private val function: (Double) -> Unit): Func_void_double {
+  @DoNotStrip
+  @Keep
+  override fun invoke(progress: Double): Unit {
+    return this.function(progress)
+  }
+}

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

@@ -58,6 +58,19 @@ abstract class HybridLiteRTLMSpec: HybridObject() {
   @Keep
   abstract fun sendMessageWithImage(message: String, imagePath: String): Promise<String>
   
+  abstract fun downloadModel(url: String, fileName: String, onProgress: ((progress: Double) -> Unit)?): Promise<String>
+  
+  @DoNotStrip
+  @Keep
+  private fun downloadModel_cxx(url: String, fileName: String, onProgress: Func_void_double?): Promise<String> {
+    val __result = downloadModel(url, fileName, onProgress?.let { it })
+    return __result
+  }
+  
+  @DoNotStrip
+  @Keep
+  abstract fun deleteModel(fileName: String): Promise<Unit>
+  
   @DoNotStrip
   @Keep
   abstract fun sendMessageWithAudio(message: String, audioPath: String): Promise<String>
@@ -87,6 +100,10 @@ abstract class HybridLiteRTLMSpec: HybridObject() {
   @Keep
   abstract fun getStats(): GenerationStats
   
+  @DoNotStrip
+  @Keep
+  abstract fun getMemoryUsage(): MemoryUsage
+  
   @DoNotStrip
   @Keep
   abstract fun close(): Unit