react-native-litert-lm 0.1.1 → 0.2.1

package/lib/hooks.d.ts

@@ -0,0 +1,16 @@
+import { LiteRTLM, LLMConfig } from "./index";
+export interface UseModelConfig extends LLMConfig {
+    autoLoad?: boolean;
+}
+export interface UseModelResult {
+    model: LiteRTLM | null;
+    isReady: boolean;
+    isGenerating: boolean;
+    downloadProgress: number;
+    error: string | null;
+    generate: (prompt: string) => Promise<string>;
+    reset: () => void;
+    deleteModel: (fileName: string) => Promise<void>;
+    load: () => Promise<void>;
+}
+export declare function useModel(pathOrUrl: string, config?: UseModelConfig): UseModelResult;

package/lib/hooks.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useModel = useModel;
+const react_1 = require("react");
+const modelFactory_1 = require("./modelFactory");
+function useModel(pathOrUrl, config) {
+    const modelRef = (0, react_1.useRef)(null);
+    const [isReady, setIsReady] = (0, react_1.useState)(false);
+    const [isGenerating, setIsGenerating] = (0, react_1.useState)(false);
+    const [downloadProgress, setDownloadProgress] = (0, react_1.useState)(0);
+    const [error, setError] = (0, react_1.useState)(null);
+    // Extract autoLoad (default true)
+    const autoLoad = config?.autoLoad ?? true;
+    // Initialize the model instance
+    (0, react_1.useEffect)(() => {
+        modelRef.current = (0, modelFactory_1.createLLM)();
+        let isMounted = true;
+        // Cleanup on unmount
+        return () => {
+            isMounted = false;
+            try {
+                modelRef.current?.close();
+            }
+            catch (e) {
+                console.warn("Failed to close model", e);
+            }
+        };
+    }, []);
+    const load = (0, react_1.useCallback)(async () => {
+        setIsReady(false);
+        setError(null);
+        setDownloadProgress(0);
+        try {
+            let modelPath = pathOrUrl;
+            // Handle URL download manually to capture progress
+            if (pathOrUrl.startsWith("http://") || pathOrUrl.startsWith("https://")) {
+                const fileName = pathOrUrl.split("/").pop() || "model.bin";
+                if (modelRef.current) {
+                    modelPath = await modelRef.current.downloadModel(pathOrUrl, fileName, (progress) => {
+                        setDownloadProgress(progress);
+                    });
+                }
+            }
+            if (modelRef.current) {
+                // Create a clean config object for native loadModel (excluding autoLoad)
+                const nativeConfig = { ...config };
+                delete nativeConfig.autoLoad;
+                await modelRef.current.loadModel(modelPath, nativeConfig);
+                setIsReady(true);
+            }
+        }
+        catch (e) {
+            setError(e.message || "Failed to load model");
+            console.error(e);
+        }
+    }, [pathOrUrl, config]);
+    (0, react_1.useEffect)(() => {
+        if (autoLoad) {
+            load();
+        }
+    }, [autoLoad, load]);
+    const generate = (0, react_1.useCallback)(async (prompt) => {
+        if (!modelRef.current || !isReady) {
+            throw new Error("Model not ready");
+        }
+        setIsGenerating(true);
+        try {
+            return new Promise((resolve, reject) => {
+                let fullResponse = "";
+                try {
+                    modelRef.current?.sendMessageAsync(prompt, (token, done) => {
+                        fullResponse += token;
+                        if (done) {
+                            resolve(fullResponse);
+                        }
+                    });
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+        }
+        catch (e) {
+            setError(e.message || "Generation failed");
+            throw e;
+        }
+        finally {
+            setIsGenerating(false);
+        }
+    }, [isReady]);
+    const reset = (0, react_1.useCallback)(() => {
+        if (modelRef.current) {
+            modelRef.current.resetConversation();
+        }
+    }, []);
+    const deleteModel = (0, react_1.useCallback)(async (fileName) => {
+        if (modelRef.current) {
+            await modelRef.current.deleteModel(fileName);
+            setIsReady(false);
+            setDownloadProgress(0);
+        }
+    }, []);
+    return {
+        model: modelRef.current,
+        isReady,
+        isGenerating,
+        downloadProgress,
+        error,
+        generate,
+        reset,
+        deleteModel,
+        load,
+    };
+}

package/lib/index.d.ts

@@ -1,5 +1,8 @@
-import type { LiteRTLM, Backend } from "./specs/LiteRTLM.nitro";
+import type { Backend } from "./specs/LiteRTLM.nitro";
 export type { LiteRTLM, LLMConfig, Message, Backend, Role, GenerationStats, } from "./specs/LiteRTLM.nitro";
+export type { ChatMessage } from "./templates";
+export { applyGemmaTemplate, applyPhiTemplate, applyLlamaTemplate, } from "./templates";
+export * from "./hooks";
 /**
  * Creates a new LiteRT-LM inference engine instance.
  *
@@ -33,7 +36,7 @@ export type { LiteRTLM, LLMConfig, Message, Backend, Role, GenerationStats, } fr
  * llm.close();
  * ```
  */
-export declare function createLLM(): LiteRTLM;
+export { createLLM } from "./modelFactory";
 /**
  * Pre-defined model identifiers for common models.
  * Use with model download utilities or as reference.
@@ -80,3 +83,25 @@ export declare function getRecommendedBackend(): Backend;
  * ```
  */
 export declare function checkBackendSupport(backend: Backend): string | undefined;
+/**
+ * Check if multimodal features (image/audio) are supported on the current platform.
+ * Returns an error message if not supported, undefined if OK.
+ *
+ * @returns Error message if multimodal is not supported, undefined if OK
+ *
+ * @example
+ * ```typescript
+ * const error = checkMultimodalSupport();
+ * if (error) {
+ *   console.warn(error);
+ *   // Fall back to text-only
+ * } else {
+ *   llm.sendMessageWithImage('Describe this', imagePath);
+ * }
+ * ```
+ */
+export declare function checkMultimodalSupport(): string | undefined;
+/**
+ * Download URL for the Gemma 3n E2B IT INT4 model.
+ */
+export declare const GEMMA_3N_E2B_IT_INT4 = "https://litert.dev/gemma-3n-E2B-it-int4.litertlm";

package/lib/index.js

@@ -1,11 +1,29 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Models = void 0;
-exports.createLLM = createLLM;
+exports.GEMMA_3N_E2B_IT_INT4 = exports.Models = exports.createLLM = exports.applyLlamaTemplate = exports.applyPhiTemplate = exports.applyGemmaTemplate = void 0;
 exports.getRecommendedBackend = getRecommendedBackend;
 exports.checkBackendSupport = checkBackendSupport;
-const react_native_nitro_modules_1 = require("react-native-nitro-modules");
+exports.checkMultimodalSupport = checkMultimodalSupport;
 const react_native_1 = require("react-native");
+var templates_1 = require("./templates");
+Object.defineProperty(exports, "applyGemmaTemplate", { enumerable: true, get: function () { return templates_1.applyGemmaTemplate; } });
+Object.defineProperty(exports, "applyPhiTemplate", { enumerable: true, get: function () { return templates_1.applyPhiTemplate; } });
+Object.defineProperty(exports, "applyLlamaTemplate", { enumerable: true, get: function () { return templates_1.applyLlamaTemplate; } });
+__exportStar(require("./hooks"), exports);
 /**
  * Creates a new LiteRT-LM inference engine instance.
  *
@@ -39,9 +57,8 @@ const react_native_1 = require("react-native");
  * llm.close();
  * ```
  */
-function createLLM() {
-    return react_native_nitro_modules_1.NitroModules.createHybridObject("LiteRTLM");
-}
+var modelFactory_1 = require("./modelFactory");
+Object.defineProperty(exports, "createLLM", { enumerable: true, get: function () { return modelFactory_1.createLLM; } });
 /**
  * Pre-defined model identifiers for common models.
  * Use with model download utilities or as reference.
@@ -104,3 +121,30 @@ function checkBackendSupport(backend) {
     }
     return undefined;
 }
+/**
+ * Check if multimodal features (image/audio) are supported on the current platform.
+ * Returns an error message if not supported, undefined if OK.
+ *
+ * @returns Error message if multimodal is not supported, undefined if OK
+ *
+ * @example
+ * ```typescript
+ * const error = checkMultimodalSupport();
+ * if (error) {
+ *   console.warn(error);
+ *   // Fall back to text-only
+ * } else {
+ *   llm.sendMessageWithImage('Describe this', imagePath);
+ * }
+ * ```
+ */
+function checkMultimodalSupport() {
+    if (react_native_1.Platform.OS === "ios") {
+        return "Multimodal (image/audio) is not yet supported on iOS. LiteRT-LM iOS SDK is pending.";
+    }
+    return undefined;
+}
+/**
+ * Download URL for the Gemma 3n E2B IT INT4 model.
+ */
+exports.GEMMA_3N_E2B_IT_INT4 = "https://litert.dev/gemma-3n-E2B-it-int4.litertlm";

package/lib/modelFactory.d.ts

@@ -0,0 +1,5 @@
+import { LiteRTLM } from "./specs/LiteRTLM.nitro";
+/**
+ * Creates a new LiteRT-LM inference engine instance.
+ */
+export declare function createLLM(): LiteRTLM;

package/lib/modelFactory.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLLM = createLLM;
+const react_native_nitro_modules_1 = require("react-native-nitro-modules");
+/**
+ * Creates a new LiteRT-LM inference engine instance.
+ */
+function createLLM() {
+    const native = react_native_nitro_modules_1.NitroModules.createHybridObject("LiteRTLM");
+    return {
+        ...native,
+        loadModel: async (pathOrUrl, config) => {
+            let modelPath = pathOrUrl;
+            // Check if it's a URL
+            if (pathOrUrl.startsWith("http://") || pathOrUrl.startsWith("https://")) {
+                // Extract filename from URL
+                const fileName = pathOrUrl.split("/").pop();
+                if (!fileName) {
+                    throw new Error(`Invalid model URL: ${pathOrUrl}`);
+                }
+                console.log(`Checking model at ${pathOrUrl}...`);
+                modelPath = await native.downloadModel(pathOrUrl, fileName, (progress) => {
+                    console.log(`Download progress: ${progress}`);
+                });
+                console.log(`Model downloaded to: ${modelPath}`);
+            }
+            return native.loadModel(modelPath, config);
+        },
+        // Bind valid methods to native instance
+        sendMessage: native.sendMessage.bind(native),
+        sendMessageAsync: native.sendMessageAsync.bind(native),
+        sendMessageWithImage: native.sendMessageWithImage.bind(native),
+        sendMessageWithAudio: native.sendMessageWithAudio.bind(native),
+        getHistory: native.getHistory.bind(native),
+        resetConversation: native.resetConversation.bind(native),
+        isReady: native.isReady.bind(native),
+        getStats: native.getStats.bind(native),
+        close: native.close.bind(native),
+        downloadModel: native.downloadModel.bind(native),
+        deleteModel: native.deleteModel.bind(native),
+    };
+}

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)
@@ -125,6 +131,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.

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,6 +16,7 @@
 #include <NitroModules/HybridObjectRegistry.hpp>
 
 #include "JHybridLiteRTLMSpec.hpp"
+#include "JFunc_void_double.hpp"
 #include "JFunc_void_std__string_bool.hpp"
 #include <NitroModules/DefaultConstructableObject.hpp>
 
@@ -29,6 +30,7 @@ int initialize(JavaVM* vm) {
   return facebook::jni::initialize(vm, [] {
     // 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

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

@@ -35,8 +35,9 @@ namespace margelo::nitro::litertlm { enum class Backend; }
 #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 +125,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));

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

@@ -58,6 +58,8 @@ 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;

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,