react-native-litert-lm 0.4.0 → 0.4.1

package/lib/hooks.js

@@ -28,6 +28,11 @@ function useModel(pathOrUrl, config) {
     const temperature = config?.temperature;
     const topK = config?.topK;
     const topP = config?.topP;
+    const validate = config?.validate;
+    const multimodal = config?.multimodal;
+    const tools = config?.tools;
+    const enableSpeculativeDecoding = config?.enableSpeculativeDecoding;
+    const toolsKey = tools ? JSON.stringify(tools) : undefined;
     // Build a stable config object from the destructured primitives
     const nativeConfig = (0, react_1.useMemo)(() => ({
         ...(backend !== undefined && { backend }),
@@ -36,7 +41,24 @@ function useModel(pathOrUrl, config) {
         ...(temperature !== undefined && { temperature }),
         ...(topK !== undefined && { topK }),
         ...(topP !== undefined && { topP }),
-    }), [backend, systemPrompt, maxTokens, temperature, topK, topP]);
+        ...(validate !== undefined && { validate }),
+        ...(multimodal !== undefined && { multimodal }),
+        ...(tools !== undefined && { tools }),
+        ...(enableSpeculativeDecoding !== undefined && {
+            enableSpeculativeDecoding,
+        }),
+    }), [
+        backend,
+        systemPrompt,
+        maxTokens,
+        temperature,
+        topK,
+        topP,
+        validate,
+        multimodal,
+        toolsKey,
+        enableSpeculativeDecoding,
+    ]);
     /**
      * Refresh memory summary from the tracker's native buffer.
      */
@@ -99,13 +121,15 @@ function useModel(pathOrUrl, config) {
             return new Promise((resolve, reject) => {
                 let fullResponse = "";
                 try {
-                    modelRef.current?.sendMessageAsync(prompt, (token, done) => {
+                    modelRef.current
+                        ?.sendMessageAsync(prompt, (token, done) => {
                         fullResponse += token;
                         if (done) {
                             refreshMemorySummary();
                             resolve(fullResponse);
                         }
-                    }).catch(reject);
+                    })
+                        .catch(reject);
                 }
                 catch (e) {
                     reject(e);

package/lib/index.d.ts

@@ -93,6 +93,12 @@ export declare function checkBackendSupport(backend: Backend): string | undefine
  * Check if multimodal features (image/audio) are supported on the current platform.
  * Returns an error message if not supported, undefined if OK.
  *
+ * Both iOS (v0.12.0 CLiteRTLM xcframework) and Android (LiteRT-LM SDK) ship the
+ * vision/audio executor ops, so there is no platform-level block. Whether a
+ * given call succeeds depends on the **loaded model**: only multimodal models
+ * (e.g. Gemma 3n) bundle the vision/audio executors. Pass `multimodal: true` to
+ * `loadModel` for such models, or rely on filename sniffing ("3n"/"gemma3").
+ *
  * @returns Error message if multimodal is not supported, undefined if OK
  *
  * @example

package/lib/index.js

@@ -135,6 +135,12 @@ function checkBackendSupport(backend) {
  * Check if multimodal features (image/audio) are supported on the current platform.
  * Returns an error message if not supported, undefined if OK.
  *
+ * Both iOS (v0.12.0 CLiteRTLM xcframework) and Android (LiteRT-LM SDK) ship the
+ * vision/audio executor ops, so there is no platform-level block. Whether a
+ * given call succeeds depends on the **loaded model**: only multimodal models
+ * (e.g. Gemma 3n) bundle the vision/audio executors. Pass `multimodal: true` to
+ * `loadModel` for such models, or rely on filename sniffing ("3n"/"gemma3").
+ *
  * @returns Error message if multimodal is not supported, undefined if OK
  *
  * @example
@@ -149,9 +155,7 @@ function checkBackendSupport(backend) {
  * ```
  */
 function checkMultimodalSupport() {
-    if (react_native_1.Platform.OS === "ios") {
-        return "Multimodal (image/audio) is not available on iOS. The XCFramework lacks compiled vision and audio executor ops.";
-    }
+    // Supported on both platforms with a multimodal model loaded.
     return undefined;
 }
 /**

package/lib/modelFactory.js

@@ -95,6 +95,26 @@ function createLLM(options) {
                     });
                 };
             }
+            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);

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

@@ -204,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.
@@ -224,6 +232,14 @@ 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).

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

@@ -47,15 +47,15 @@ namespace margelo::nitro::litertlm { enum class PartType; }
 #include "ToolDefinition.hpp"
 #include "JToolDefinition.hpp"
 #include <functional>
-#include "JFunc_void_double.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>
-#include "JFunc_void_std__string_bool.hpp"
 
 namespace margelo::nitro::litertlm {
 
@@ -137,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);
@@ -184,6 +199,21 @@ namespace margelo::nitro::litertlm {
       return __promise;
     }();
   }
+  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) {

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

@@ -57,9 +57,11 @@ 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;
+    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;

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

@@ -41,6 +41,15 @@ abstract class HybridLiteRTLMSpec: HybridObject() {
   @Keep
   abstract fun sendMessageWithImage(message: String, imagePath: String): Promise<String>
   
+  abstract fun sendMessageWithImageAsync(message: String, imagePath: String, onToken: (token: String, done: Boolean) -> Unit): Promise<Unit>
+  
+  @DoNotStrip
+  @Keep
+  private fun sendMessageWithImageAsync_cxx(message: String, imagePath: String, onToken: Func_void_std__string_bool): Promise<Unit> {
+    val __result = sendMessageWithImageAsync(message, imagePath, onToken)
+    return __result
+  }
+  
   abstract fun downloadModel(url: String, fileName: String, onProgress: ((progress: Double) -> Unit)?): Promise<String>
   
   @DoNotStrip
@@ -58,6 +67,15 @@ abstract class HybridLiteRTLMSpec: HybridObject() {
   @Keep
   abstract fun sendMessageWithAudio(message: String, audioPath: String): Promise<String>
   
+  abstract fun sendMessageWithAudioAsync(message: String, audioPath: String, onToken: (token: String, done: Boolean) -> Unit): Promise<Unit>
+  
+  @DoNotStrip
+  @Keep
+  private fun sendMessageWithAudioAsync_cxx(message: String, audioPath: String, onToken: Func_void_std__string_bool): Promise<Unit> {
+    val __result = sendMessageWithAudioAsync(message, audioPath, onToken)
+    return __result
+  }
+  
   @DoNotStrip
   @Keep
   abstract fun sendMultimodalMessage(parts: Array<MultimodalPart>): Promise<String>

package/nitrogen/generated/ios/LiteRTLM-Swift-Cxx-Bridge.cpp

@@ -38,14 +38,6 @@ namespace margelo::nitro::litertlm::bridge::swift {
     };
   }
   
-  // pragma MARK: std::function<void(double /* progress */)>
-  Func_void_double create_Func_void_double(void* NON_NULL swiftClosureWrapper) noexcept {
-    auto swiftClosure = LiteRTLM::Func_void_double::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](double progress) mutable -> void {
-      swiftClosure.call(progress);
-    };
-  }
-  
   // pragma MARK: std::function<void(const std::string& /* token */, bool /* done */)>
   Func_void_std__string_bool create_Func_void_std__string_bool(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = LiteRTLM::Func_void_std__string_bool::fromUnsafe(swiftClosureWrapper);
@@ -54,6 +46,14 @@ namespace margelo::nitro::litertlm::bridge::swift {
     };
   }
   
+  // pragma MARK: std::function<void(double /* progress */)>
+  Func_void_double create_Func_void_double(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = LiteRTLM::Func_void_double::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](double progress) mutable -> void {
+      swiftClosure.call(progress);
+    };
+  }
+  
   // pragma MARK: std::shared_ptr<HybridLiteRTLMSpec>
   std::shared_ptr<HybridLiteRTLMSpec> create_std__shared_ptr_HybridLiteRTLMSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     LiteRTLM::HybridLiteRTLMSpec_cxx swiftPart = LiteRTLM::HybridLiteRTLMSpec_cxx::fromUnsafe(swiftUnsafePointer);

package/nitrogen/generated/ios/LiteRTLM-Swift-Cxx-Bridge.hpp

@@ -255,6 +255,28 @@ namespace margelo::nitro::litertlm::bridge::swift {
     return Func_void_std__string_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::function<void(const std::string& /* token */, bool /* done */)>
+  /**
+   * Specialized version of `std::function<void(const std::string&, bool)>`.
+   */
+  using Func_void_std__string_bool = std::function<void(const std::string& /* token */, bool /* done */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::string& / * token * /, bool / * done * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__string_bool_Wrapper final {
+  public:
+    explicit Func_void_std__string_bool_Wrapper(std::function<void(const std::string& /* token */, bool /* done */)>&& func): _function(std::make_unique<std::function<void(const std::string& /* token */, bool /* done */)>>(std::move(func))) {}
+    inline void call(std::string token, bool done) const noexcept {
+      _function->operator()(token, done);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::string& /* token */, bool /* done */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__string_bool create_Func_void_std__string_bool(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__string_bool_Wrapper wrap_Func_void_std__string_bool(Func_void_std__string_bool value) noexcept {
+    return Func_void_std__string_bool_Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::function<void(double /* progress */)>
   /**
    * Specialized version of `std::function<void(double)>`.
@@ -318,28 +340,6 @@ namespace margelo::nitro::litertlm::bridge::swift {
     return vector;
   }
   
-  // pragma MARK: std::function<void(const std::string& /* token */, bool /* done */)>
-  /**
-   * Specialized version of `std::function<void(const std::string&, bool)>`.
-   */
-  using Func_void_std__string_bool = std::function<void(const std::string& /* token */, bool /* done */)>;
-  /**
-   * Wrapper class for a `std::function<void(const std::string& / * token * /, bool / * done * /)>`, this can be used from Swift.
-   */
-  class Func_void_std__string_bool_Wrapper final {
-  public:
-    explicit Func_void_std__string_bool_Wrapper(std::function<void(const std::string& /* token */, bool /* done */)>&& func): _function(std::make_unique<std::function<void(const std::string& /* token */, bool /* done */)>>(std::move(func))) {}
-    inline void call(std::string token, bool done) const noexcept {
-      _function->operator()(token, done);
-    }
-  private:
-    std::unique_ptr<std::function<void(const std::string& /* token */, bool /* done */)>> _function;
-  } SWIFT_NONCOPYABLE;
-  Func_void_std__string_bool create_Func_void_std__string_bool(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_void_std__string_bool_Wrapper wrap_Func_void_std__string_bool(Func_void_std__string_bool value) noexcept {
-    return Func_void_std__string_bool_Wrapper(std::move(value));
-  }
-  
   // pragma MARK: std::vector<Message>
   /**
    * Specialized version of `std::vector<Message>`.

package/nitrogen/generated/ios/c++/HybridLiteRTLMSpecSwift.hpp

@@ -124,6 +124,14 @@ namespace margelo::nitro::litertlm {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline 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 {
+      auto __result = _swiftPart.sendMessageWithImageAsync(message, imagePath, onToken);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline 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 {
       auto __result = _swiftPart.downloadModel(url, fileName, onProgress);
       if (__result.hasError()) [[unlikely]] {
@@ -148,6 +156,14 @@ namespace margelo::nitro::litertlm {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline 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 {
+      auto __result = _swiftPart.sendMessageWithAudioAsync(message, audioPath, onToken);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline std::shared_ptr<Promise<std::string>> sendMultimodalMessage(const std::vector<MultimodalPart>& parts) override {
       auto __result = _swiftPart.sendMultimodalMessage(parts);
       if (__result.hasError()) [[unlikely]] {

package/nitrogen/generated/ios/swift/HybridLiteRTLMSpec.swift

@@ -16,9 +16,11 @@ public protocol HybridLiteRTLMSpec_protocol: HybridObject {
   func loadModel(modelPath: String, config: LLMConfig?) throws -> Promise<Void>
   func sendMessage(message: String) throws -> Promise<String>
   func sendMessageWithImage(message: String, imagePath: String) throws -> Promise<String>
+  func sendMessageWithImageAsync(message: String, imagePath: String, onToken: @escaping (_ token: String, _ done: Bool) -> Void) throws -> Promise<Void>
   func downloadModel(url: String, fileName: String, onProgress: ((_ progress: Double) -> Void)?) throws -> Promise<String>
   func deleteModel(fileName: String) throws -> Promise<Void>
   func sendMessageWithAudio(message: String, audioPath: String) throws -> Promise<String>
+  func sendMessageWithAudioAsync(message: String, audioPath: String, onToken: @escaping (_ token: String, _ done: Bool) -> Void) throws -> Promise<Void>
   func sendMultimodalMessage(parts: [MultimodalPart]) throws -> Promise<String>
   func sendMessageAsync(message: String, onToken: @escaping (_ token: String, _ done: Bool) -> Void) throws -> Promise<Void>
   func getHistory() throws -> [Message]

package/nitrogen/generated/ios/swift/HybridLiteRTLMSpec_cxx.swift

@@ -181,6 +181,30 @@ open class HybridLiteRTLMSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func sendMessageWithImageAsync(message: std.string, imagePath: std.string, onToken: bridge.Func_void_std__string_bool) -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.sendMessageWithImageAsync(message: String(message), imagePath: String(imagePath), onToken: { () -> (String, Bool) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_std__string_bool(onToken)
+        return { (__token: String, __done: Bool) -> Void in
+          __wrappedFunction.call(std.string(__token), __done)
+        }
+      }())
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func downloadModel(url: std.string, fileName: std.string, onProgress: bridge.std__optional_std__function_void_double____progress______) -> bridge.Result_std__shared_ptr_Promise_std__string___ {
     do {
@@ -250,6 +274,30 @@ open class HybridLiteRTLMSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func sendMessageWithAudioAsync(message: std.string, audioPath: std.string, onToken: bridge.Func_void_std__string_bool) -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.sendMessageWithAudioAsync(message: String(message), audioPath: String(audioPath), onToken: { () -> (String, Bool) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_std__string_bool(onToken)
+        return { (__token: String, __done: Bool) -> Void in
+          __wrappedFunction.call(std.string(__token), __done)
+        }
+      }())
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func sendMultimodalMessage(parts: bridge.std__vector_MultimodalPart_) -> bridge.Result_std__shared_ptr_Promise_std__string___ {
     do {

package/nitrogen/generated/shared/c++/HybridLiteRTLMSpec.cpp

@@ -17,9 +17,11 @@ namespace margelo::nitro::litertlm {
       prototype.registerHybridMethod("loadModel", &HybridLiteRTLMSpec::loadModel);
       prototype.registerHybridMethod("sendMessage", &HybridLiteRTLMSpec::sendMessage);
       prototype.registerHybridMethod("sendMessageWithImage", &HybridLiteRTLMSpec::sendMessageWithImage);
+      prototype.registerHybridMethod("sendMessageWithImageAsync", &HybridLiteRTLMSpec::sendMessageWithImageAsync);
       prototype.registerHybridMethod("downloadModel", &HybridLiteRTLMSpec::downloadModel);
       prototype.registerHybridMethod("deleteModel", &HybridLiteRTLMSpec::deleteModel);
       prototype.registerHybridMethod("sendMessageWithAudio", &HybridLiteRTLMSpec::sendMessageWithAudio);
+      prototype.registerHybridMethod("sendMessageWithAudioAsync", &HybridLiteRTLMSpec::sendMessageWithAudioAsync);
       prototype.registerHybridMethod("sendMultimodalMessage", &HybridLiteRTLMSpec::sendMultimodalMessage);
       prototype.registerHybridMethod("sendMessageAsync", &HybridLiteRTLMSpec::sendMessageAsync);
       prototype.registerHybridMethod("getHistory", &HybridLiteRTLMSpec::getHistory);

package/nitrogen/generated/shared/c++/HybridLiteRTLMSpec.hpp

@@ -69,9 +69,11 @@ namespace margelo::nitro::litertlm {
       virtual std::shared_ptr<Promise<void>> loadModel(const std::string& modelPath, const std::optional<LLMConfig>& config) = 0;
       virtual std::shared_ptr<Promise<std::string>> sendMessage(const std::string& message) = 0;
       virtual std::shared_ptr<Promise<std::string>> sendMessageWithImage(const std::string& message, const std::string& imagePath) = 0;
+      virtual 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) = 0;
       virtual std::shared_ptr<Promise<std::string>> downloadModel(const std::string& url, const std::string& fileName, const std::optional<std::function<void(double /* progress */)>>& onProgress) = 0;
       virtual std::shared_ptr<Promise<void>> deleteModel(const std::string& fileName) = 0;
       virtual std::shared_ptr<Promise<std::string>> sendMessageWithAudio(const std::string& message, const std::string& audioPath) = 0;
+      virtual 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) = 0;
       virtual std::shared_ptr<Promise<std::string>> sendMultimodalMessage(const std::vector<MultimodalPart>& parts) = 0;
       virtual std::shared_ptr<Promise<void>> sendMessageAsync(const std::string& message, const std::function<void(const std::string& /* token */, bool /* done */)>& onToken) = 0;
       virtual std::vector<Message> getHistory() = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-litert-lm",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "litertLm": {
     "version": "0.12.0",
     "androidMavenVersion": "0.12.0",
@@ -49,6 +49,7 @@
     "cpp",
     "nitrogen/generated",
     "scripts/postinstall.js",
+    "scripts/framework-source.js",
     "scripts/download-ios-frameworks.sh",
     "react-native.config.js",
     "react-native-litert-lm.podspec",
@@ -65,10 +66,12 @@
     "typecheck": "tsc --noEmit",
     "test": "jest",
     "lint": "eslint \"**/*.{js,ts,tsx}\" --fix",
-    "prepack": "npm run build",
+    "prepack": "npx nitrogen && npm run build",
     "specs": "npx nitrogen",
     "clean": "rm -rf lib android/build ios/build ios/Frameworks nitrogen/generated",
     "download-frameworks": "scripts/download-ios-frameworks.sh",
+    "check-framework-release": "node scripts/check-framework-release.js",
+    "prepublishOnly": "node scripts/check-framework-release.js",
     "android": "expo run:android",
     "android:clean": "cd android && ./gradlew clean",
     "ios": "expo run:ios",
@@ -82,7 +85,7 @@
     "jest": "^30.4.2",
     "react": "^19.2.6",
     "react-native": "^0.85.3",
-    "react-native-nitro-modules": "^0.35.4",
+    "react-native-nitro-modules": "^0.35.9",
     "react-test-renderer": "^19.2.6",
     "release-it": "^19.2.4",
     "ts-jest": "^29.4.10",
@@ -93,7 +96,7 @@
     "expo": ">=55.0.0",
     "react": "*",
     "react-native": "*",
-    "react-native-nitro-modules": "^0.35.4"
+    "react-native-nitro-modules": "^0.35.9"
   },
   "peerDependenciesMeta": {
     "expo": {

package/react-native-litert-lm.podspec

@@ -23,8 +23,10 @@ Pod::Spec.new do |s|
     "nitrogen/generated/shared/c++/**/*.{hpp,cpp}",
   ]
 
-  # Prebuilt LiteRT-LM C engine (static library).
-  # Downloaded from Google's release via: scripts/download-ios-frameworks.sh
+  # Prebuilt LiteRT-LM C engine (xcframework). Not shipped in the npm tarball;
+  # fetched on install by scripts/postinstall.js (asset/tag defined in
+  # scripts/framework-source.js). Manual/upstream fallback:
+  # scripts/download-ios-frameworks.sh.
   s.vendored_frameworks = 'ios/Frameworks/CLiteRTLM.xcframework'
 
   s.pod_target_xcconfig = {

package/scripts/download-ios-frameworks.sh

@@ -7,10 +7,11 @@ set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
-OUTPUT_DIR="$PROJECT_ROOT/ios/Frameworks"
 
-LITERT_LM_VERSION="$(node -e "console.log(require('$PROJECT_ROOT/package.json').litertLm.iosGitTag)")"
-RELEASE_URL="https://github.com/google-ai-edge/LiteRT-LM/releases/download/${LITERT_LM_VERSION}/CLiteRTLM.xcframework.zip"
+# Resolve the asset URL + output dir from the shared single source of truth
+# (scripts/framework-source.js) so this manual path can't drift from postinstall.
+RELEASE_URL="$(node -e "console.log(require('$SCRIPT_DIR/framework-source').ASSET_URL)")"
+OUTPUT_DIR="$(node -e "console.log(require('$SCRIPT_DIR/framework-source').FRAMEWORKS_DIR)")"
 
 # Skip if already present
 if [ -d "$OUTPUT_DIR/CLiteRTLM.xcframework" ]; then

package/scripts/framework-source.js

@@ -0,0 +1,46 @@
+/**
+ * framework-source.js
+ *
+ * Single source of truth for the prebuilt iOS framework artifact, shared by
+ * scripts/postinstall.js, scripts/download-ios-frameworks.sh, and
+ * scripts/check-framework-release.js, so the asset name, tag, and URL can never
+ * drift between the install path and the release-time guardrail.
+ *
+ * The artifact is Google's canonical LiteRT-LM release (NOT a per-version
+ * re-host of this package), pinned to the LiteRT-LM **engine** version
+ * (`litertLm.iosGitTag` in package.json), NOT this wrapper's npm version. So:
+ *   - patch releases of this wrapper reuse the same framework (no re-upload),
+ *   - there is no per-release asset for the maintainer to forget to upload,
+ *   - the guardrail checks the exact URL consumers fetch.
+ *
+ * Override the host/asset (e.g. to point at a private mirror) via env vars:
+ *   LITERT_FRAMEWORK_REPO   (default: google-ai-edge/LiteRT-LM)
+ *   LITERT_FRAMEWORK_ASSET  (default: CLiteRTLM.xcframework.zip)
+ */
+
+const path = require('path');
+const packageJson = require('../package.json');
+
+/** GitHub repo that hosts the framework release asset. */
+const GITHUB_REPO = process.env.LITERT_FRAMEWORK_REPO || 'google-ai-edge/LiteRT-LM';
+
+/** Release asset filename. Must match the file on the GitHub release. */
+const ASSET_NAME = process.env.LITERT_FRAMEWORK_ASSET || 'CLiteRTLM.xcframework.zip';
+
+/** Release tag the asset lives under — the LiteRT-LM engine git tag, e.g. "v0.12.0". */
+const FRAMEWORK_TAG = packageJson.litertLm.iosGitTag;
+
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+const FRAMEWORKS_DIR = path.join(PACKAGE_ROOT, 'ios', 'Frameworks');
+
+/** Fully-resolved download URL for the framework zip. */
+const ASSET_URL = `https://github.com/${GITHUB_REPO}/releases/download/${FRAMEWORK_TAG}/${ASSET_NAME}`;
+
+module.exports = {
+  GITHUB_REPO,
+  ASSET_NAME,
+  FRAMEWORK_TAG,
+  PACKAGE_ROOT,
+  FRAMEWORKS_DIR,
+  ASSET_URL,
+};