react-native-litert-lm 0.3.7 → 0.4.1

package/lib/modelFactory.js

@@ -38,72 +38,91 @@ function createLLM(options) {
             // Ignore errors during memory tracking - it's non-critical
         }
     };
-    return {
-        ...native,
-        memoryTracker: tracker,
-        loadModel: async (pathOrUrl, config, onDownloadProgress) => {
-            let modelPath = pathOrUrl;
-            // Check if it's a URL — enforce HTTPS for model downloads
-            if (pathOrUrl.startsWith("http://") || pathOrUrl.startsWith("https://")) {
-                if (pathOrUrl.startsWith("http://")) {
-                    throw new Error("Insecure HTTP URLs are not allowed for model downloads. " +
-                        "Use HTTPS instead: " +
-                        pathOrUrl.replace("http://", "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) => {
-                    onDownloadProgress?.(progress);
-                });
-                console.log(`Model downloaded to: ${modelPath}`);
+    const augmentedLoadModel = async (pathOrUrl, config, onDownloadProgress) => {
+        let modelPath = pathOrUrl;
+        // Check if it's a URL — enforce HTTPS for model downloads
+        if (pathOrUrl.startsWith("http://") || pathOrUrl.startsWith("https://")) {
+            if (pathOrUrl.startsWith("http://")) {
+                throw new Error("Insecure HTTP URLs are not allowed for model downloads. " +
+                    "Use HTTPS instead: " +
+                    pathOrUrl.replace("http://", "https://"));
             }
-            const result = await native.loadModel(modelPath, config);
-            // Record initial memory snapshot after model load
-            if (tracker) {
-                tracker.reset();
-                recordMemorySnapshot();
+            // Extract filename from URL, stripping query parameters
+            const urlWithoutQuery = pathOrUrl.split("?")[0];
+            const fileName = urlWithoutQuery.split("/").pop();
+            if (!fileName) {
+                throw new Error(`Invalid model URL: ${pathOrUrl}`);
             }
-            return result;
-        },
-        sendMessage: async (...args) => {
-            const result = await native.sendMessage(...args);
-            recordMemorySnapshot();
-            return result;
-        },
-        sendMessageAsync: (...args) => {
-            const [message, onToken] = args;
-            native.sendMessageAsync(message, (token, done) => {
-                onToken(token, done);
-                if (done) {
-                    recordMemorySnapshot();
-                }
+            console.log(`Checking model at ${pathOrUrl}...`);
+            modelPath = await native.downloadModel(pathOrUrl, fileName, (progress) => {
+                onDownloadProgress?.(progress);
             });
-        },
-        sendMessageWithImage: async (...args) => {
-            const result = await native.sendMessageWithImage(...args);
-            recordMemorySnapshot();
-            return result;
-        },
-        sendMessageWithAudio: async (...args) => {
-            const result = await native.sendMessageWithAudio(...args);
-            recordMemorySnapshot();
-            return result;
-        },
-        getHistory: native.getHistory.bind(native),
-        resetConversation: () => {
-            native.resetConversation();
-            // KV cache is cleared on reset, record the drop
+            console.log(`Model downloaded to: ${modelPath}`);
+        }
+        const result = await native.loadModel(modelPath, config);
+        // Record initial memory snapshot after model load
+        if (tracker) {
+            tracker.reset();
             recordMemorySnapshot();
-        },
-        isReady: native.isReady.bind(native),
-        getStats: native.getStats.bind(native),
-        getMemoryUsage: native.getMemoryUsage.bind(native),
-        close: native.close.bind(native),
-        downloadModel: native.downloadModel.bind(native),
-        deleteModel: native.deleteModel.bind(native),
+        }
+        return result;
     };
+    const SNAPSHOT_TRIGGERS = new Set([
+        "sendMessage",
+        "sendMessageWithImage",
+        "sendMessageWithAudio",
+        "resetConversation",
+    ]);
+    return new Proxy(native, {
+        get(target, prop, receiver) {
+            if (prop === "memoryTracker") {
+                return tracker;
+            }
+            if (prop === "loadModel") {
+                return augmentedLoadModel;
+            }
+            const original = Reflect.get(target, prop, receiver);
+            if (typeof original !== "function") {
+                return original;
+            }
+            if (prop === "sendMessageAsync") {
+                return (message, onToken) => {
+                    return original.call(target, message, (token, done) => {
+                        onToken(token, done);
+                        if (done) {
+                            recordMemorySnapshot();
+                        }
+                    });
+                };
+            }
+            if (prop === "sendMessageWithImageAsync") {
+                return (message, imagePath, onToken) => {
+                    return original.call(target, message, imagePath, (token, done) => {
+                        onToken(token, done);
+                        if (done) {
+                            recordMemorySnapshot();
+                        }
+                    });
+                };
+            }
+            if (prop === "sendMessageWithAudioAsync") {
+                return (message, audioPath, onToken) => {
+                    return original.call(target, message, audioPath, (token, done) => {
+                        onToken(token, done);
+                        if (done) {
+                            recordMemorySnapshot();
+                        }
+                    });
+                };
+            }
+            if (SNAPSHOT_TRIGGERS.has(prop)) {
+                return async (...args) => {
+                    const result = await original.apply(target, args);
+                    recordMemorySnapshot();
+                    return result;
+                };
+            }
+            return original.bind(target);
+        },
+    });
 }

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";
 }> {
     /**
@@ -145,6 +204,14 @@ export interface LiteRTLM extends HybridObject<{
      * @returns The model's response text.
      */
     sendMessageWithImage(message: string, imagePath: string): Promise<string>;
+    /**
+     * Send a text message with an image and get a streaming response.
+     * Tokens are delivered via callback as they are generated.
+     * @param message User message text.
+     * @param imagePath Absolute path to an image file.
+     * @param onToken Callback invoked for each token (token, isDone).
+     */
+    sendMessageWithImageAsync(message: string, imagePath: string, onToken: (token: string, done: boolean) => void): Promise<void>;
     /**
      * Download a model file from a URL.
      * @param url URL to download from.
@@ -165,13 +232,27 @@ export interface LiteRTLM extends HybridObject<{
      * @returns The model's response text.
      */
     sendMessageWithAudio(message: string, audioPath: string): Promise<string>;
+    /**
+     * Send a text message with audio and get a streaming response.
+     * Tokens are delivered via callback as they are generated.
+     * @param message User message text.
+     * @param audioPath Absolute path to an audio file (WAV).
+     * @param onToken Callback invoked for each token (token, isDone).
+     */
+    sendMessageWithAudioAsync(message: string, audioPath: string, onToken: (token: string, done: boolean) => void): Promise<void>;
+    /**
+     * 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 +270,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/LiteRTLMOnLoad.cpp

@@ -16,8 +16,8 @@
 #include <NitroModules/HybridObjectRegistry.hpp>
 
 #include "JHybridLiteRTLMSpec.hpp"
-#include "JFunc_void_double.hpp"
 #include "JFunc_void_std__string_bool.hpp"
+#include "JFunc_void_double.hpp"
 #include <NitroModules/DefaultConstructableObject.hpp>
 
 namespace margelo::nitro::litertlm {
@@ -43,8 +43,8 @@ void registerAllNatives() {
 
   // Register native JNI methods
   margelo::nitro::litertlm::JHybridLiteRTLMSpec::CxxPart::registerNatives();
-  margelo::nitro::litertlm::JFunc_void_double_cxx::registerNatives();
   margelo::nitro::litertlm::JFunc_void_std__string_bool_cxx::registerNatives();
+  margelo::nitro::litertlm::JFunc_void_double_cxx::registerNatives();
 
   // Register Nitro Hybrid Objects
   HybridObjectRegistry::registerHybridObjectConstructor(

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,10 +44,18 @@ 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 "JFunc_void_std__string_bool.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "JFunc_void_double.hpp"
+#include "MultimodalPart.hpp"
+#include "JMultimodalPart.hpp"
+#include "PartType.hpp"
+#include "JPartType.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/JArrayBuffer.hpp>
 
 namespace margelo::nitro::litertlm {
 
@@ -123,6 +137,21 @@ namespace margelo::nitro::litertlm {
       return __promise;
     }();
   }
+  std::shared_ptr<Promise<void>> JHybridLiteRTLMSpec::sendMessageWithImageAsync(const std::string& message, const std::string& imagePath, 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<jni::JString> /* imagePath */, jni::alias_ref<JFunc_void_std__string_bool::javaobject> /* onToken */)>("sendMessageWithImageAsync_cxx");
+    auto __result = method(_javaPart, jni::make_jstring(message), jni::make_jstring(imagePath), 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::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 = _javaPart->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);
@@ -170,23 +199,74 @@ 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<void>> JHybridLiteRTLMSpec::sendMessageWithAudioAsync(const std::string& message, const std::string& audioPath, 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<jni::JString> /* audioPath */, jni::alias_ref<JFunc_void_std__string_bool::javaobject> /* onToken */)>("sendMessageWithAudioAsync_cxx");
+    auto __result = method(_javaPart, jni::make_jstring(message), jni::make_jstring(audioPath), 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::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 +282,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

@@ -57,14 +57,18 @@ 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<void>> sendMessageWithImageAsync(const std::string& message, const std::string& imagePath, const std::function<void(const std::string& /* token */, bool /* done */)>& onToken) 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::shared_ptr<Promise<void>> sendMessageWithAudioAsync(const std::string& message, const std::string& audioPath, 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