react-native-nobodywho 1.0.0 → 1.1.0

package/Nobodywho.podspec

@@ -8,35 +8,33 @@ folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1
 
 framework_name = "NobodywhoFramework.xcframework"
 framework_dir = File.join(__dir__, framework_name)
+zip_name = "#{framework_name}.zip"
+zip_path = File.join(__dir__, zip_name)
+url = "https://github.com/nobodywho-ooo/nobodywho/releases/download/nobodywho-react-native-#{version}/#{zip_name}"
 
-# Download the xcframework from GitHub Releases if not already present
-unless File.exist?(framework_dir)
-  zip_name = "#{framework_name}.zip"
-  zip_path = File.join(__dir__, zip_name)
-  url = "https://github.com/nobodywho-ooo/nobodywho/releases/download/nobodywho-react-native-#{version}/#{zip_name}"
-
-  puts "[NobodyWho] Downloading xcframework from #{url}"
+# Always download a fresh xcframework to ensure it matches the package version.
+FileUtils.rm_rf(framework_dir) if File.exist?(framework_dir)
 
-  # Download using curl (available on all macOS systems)
-  system("curl", "-L", "-f", "-o", zip_path, url) or
-    raise "Failed to download NobodyWho xcframework.\n" \
-          "URL: #{url}\n" \
-          "Check that the release exists: https://github.com/nobodywho-ooo/nobodywho/releases/tag/nobodywho-react-native-#{version}\n" \
-          "For local development, manually place the xcframework at: #{framework_dir}"
+puts "[NobodyWho] Downloading xcframework from #{url}"
 
-  puts "[NobodyWho] Extracting xcframework..."
-  system("unzip", "-o", "-q", zip_path, "-d", __dir__) or
-    raise "Failed to extract #{zip_name}"
+system("curl", "-L", "-f", "-o", zip_path, url) or
+  raise "Failed to download NobodyWho xcframework.\n" \
+        "URL: #{url}\n" \
+        "Check that the release exists: https://github.com/nobodywho-ooo/nobodywho/releases/tag/nobodywho-react-native-#{version}\n" \
+        "For local development, manually place the xcframework at: #{framework_dir}"
 
-  File.delete(zip_path) if File.exist?(zip_path)
+puts "[NobodyWho] Extracting xcframework..."
+system("unzip", "-o", "-q", zip_path, "-d", __dir__) or
+  raise "Failed to extract #{zip_name}"
 
-  unless File.exist?(framework_dir)
-    raise "xcframework not found after extraction: #{framework_dir}"
-  end
+File.delete(zip_path) if File.exist?(zip_path)
 
-  puts "[NobodyWho] xcframework ready at #{framework_dir}"
+unless File.exist?(framework_dir)
+  raise "xcframework not found after extraction: #{framework_dir}"
 end
 
+puts "[NobodyWho] xcframework ready at #{framework_dir}"
+
 Pod::Spec.new do |s|
   s.name         = "Nobodywho"
   s.version      = package["version"]

package/README.md

@@ -119,14 +119,14 @@ See the [Sampling documentation](https://docs.nobodywho.ooo/react-native/samplin
 
 ---
 
-## Vision
+## Vision & Hearing
 
-Vision support lets you include images in your prompts, so the model can analyze and describe visual content alongside text.
+Provide image and audio information to your LLM.
 
 To enable this, you need two model files:
 
-- A **vision-language LLM** (usually has `VL` in the name)
-- A matching **projection model** that converts images into tokens the LLM can process (usually has `mmproj` in the name)
+- A multimodal LLM, so the LLM can consume image-tokens or/and audio-tokens
+- A matching projection model, which converts images to image-tokens or/and audio to audio-tokens (usually has `mmproj` in the name)
 
 Pass the projection model when loading your model, then use `Prompt` to compose prompts that mix text and images:
 
@@ -135,17 +135,20 @@ import { Chat, Prompt } from "react-native-nobodywho";
 
 const chat = await Chat.fromPath({
   modelPath: "/path/to/vision-model.gguf",
-  imageModelPath: "/path/to/mmproj.gguf",
+  projectionModelPath: "/path/to/mmproj.gguf",
 });
 
-const prompt = new Prompt([
-  Prompt.Text("What do you see in this image?"),
-  Prompt.Image("/path/to/photo.png"),
-]);
-
-const response = await chat.ask(prompt).completed();
+const response = await chat
+  .ask(
+    new Prompt([
+      Prompt.Text("Tell me what you see in the image and what you hear in the audio."),
+      Prompt.Image("/path/to/dog.png"),
+      Prompt.Audio("/path/to/sound.mp3"),
+    ]),
+  )
+  .completed();
 ```
 
-You can pass multiple images and interleave text between them. If the model performs poorly, try reordering the text and image parts — this can make a noticeable difference. If images consume too much context, increase `contextSize` or preprocess images with compression.
+You can pass multiple images/audio files and interleave text between them. If the model performs poorly, try reordering the text, audio and image parts — this can make a noticeable difference. If images consume too much context, increase `contextSize` or preprocess images with compression.
 
-See the [Vision documentation](https://docs.nobodywho.ooo/react-native/vision/) for model recommendations and advanced tips.
+See the [Vision & Hearing documentation](https://docs.nobodywho.ooo/react-native/vision/) for model recommendations and advanced tips.

package/android/build.gradle

@@ -63,7 +63,7 @@ def nobodywhoVersion = packageJson.version
 // Directory for downloaded native shared libraries.
 // These .so files are fully linked at CI time with a known-good NDK, eliminating
 // NDK version coupling for consumers.
-def nativeLibsDir = new File(buildDir, "nobodywho-native")
+def nativeLibsDir = new File(buildDir, "nobodywho-native/${nobodywhoVersion}")
 
 // Download native shared libraries from GitHub Releases if not already present.
 task resolveNativeLibraries {

package/android/cpp-adapter.cpp

@@ -7,10 +7,10 @@
 namespace jsi = facebook::jsi;
 namespace react = facebook::react;
 
-// Automated testing checks Java_com_nobodywho_NobodywhoModule and nobodywho
+// Automated testing checks Java_ooo_nobodywho_NobodywhoModule and nobodywho
 // by comparing the whole line here.
 /*
-Java_com_nobodywho_NobodywhoModule_nativeMultiply(JNIEnv *env, jclass type, jdouble a, jdouble b) {
+Java_ooo_nobodywho_NobodywhoModule_nativeMultiply(JNIEnv *env, jclass type, jdouble a, jdouble b) {
     return nobodywho::multiply(a, b);
 }
 */
@@ -18,7 +18,7 @@ Java_com_nobodywho_NobodywhoModule_nativeMultiply(JNIEnv *env, jclass type, jdou
 // Installer coming from NobodywhoModule
 extern "C"
 JNIEXPORT jboolean JNICALL
-Java_com_nobodywho_NobodywhoModule_nativeInstallRustCrate(
+Java_ooo_nobodywho_NobodywhoModule_nativeInstallRustCrate(
     JNIEnv *env,
     jclass type,
     jlong rtPtr,
@@ -37,7 +37,7 @@ Java_com_nobodywho_NobodywhoModule_nativeInstallRustCrate(
 
 extern "C"
 JNIEXPORT jboolean JNICALL
-Java_com_nobodywho_NobodywhoModule_nativeCleanupRustCrate(JNIEnv *env, jclass type, jlong rtPtr) {
+Java_ooo_nobodywho_NobodywhoModule_nativeCleanupRustCrate(JNIEnv *env, jclass type, jlong rtPtr) {
     auto runtime = reinterpret_cast<jsi::Runtime *>(rtPtr);
     return nobodywho::cleanupRustCrate(*runtime);
 }

package/generated/cpp/nobodywho.cpp

@@ -95,9 +95,18 @@ typedef struct UniffiForeignFutureResultVoid {
 } UniffiForeignFutureResultVoid;
 typedef void (*UniffiForeignFutureCompleteVoid)(
     uint64_t callback_data, UniffiForeignFutureResultVoid result);
+typedef void (*UniffiCallbackInterfaceRustDownloadProgressCallbackMethod0)(
+    uint64_t uniffi_handle, uint64_t downloaded, uint64_t total,
+    void *uniffi_out_return, RustCallStatus *rust_call_status);
 typedef void (*UniffiCallbackInterfaceRustToolCallbackMethod0)(
     uint64_t uniffi_handle, RustBuffer arguments_json,
     RustBuffer *uniffi_out_return, RustCallStatus *rust_call_status);
+typedef struct UniffiVTableCallbackInterfaceRustDownloadProgressCallback {
+  UniffiCallbackInterfaceFree uniffi_free;
+  UniffiCallbackInterfaceClone uniffi_clone;
+  UniffiCallbackInterfaceRustDownloadProgressCallbackMethod0
+      on_download_progress;
+} UniffiVTableCallbackInterfaceRustDownloadProgressCallback;
 typedef struct UniffiVTableCallbackInterfaceRustToolCallback {
   UniffiCallbackInterfaceFree uniffi_free;
   UniffiCallbackInterfaceClone uniffi_clone;
@@ -253,12 +262,15 @@ uniffi_nobodywho_uniffi_fn_constructor_samplerconfig_from_json(
     RustBuffer json_str, RustCallStatus *uniffi_out_err);
 RustBuffer uniffi_nobodywho_uniffi_fn_method_samplerconfig_to_json(
     /*handle*/ uint64_t ptr, RustCallStatus *uniffi_out_err);
+void uniffi_nobodywho_uniffi_fn_init_callback_vtable_rustdownloadprogresscallback(
+    UniffiVTableCallbackInterfaceRustDownloadProgressCallback *vtable);
 void uniffi_nobodywho_uniffi_fn_init_callback_vtable_rusttoolcallback(
     UniffiVTableCallbackInterfaceRustToolCallback *vtable);
 float uniffi_nobodywho_uniffi_fn_func_cosine_similarity(
     RustBuffer a, RustBuffer b, RustCallStatus *uniffi_out_err);
 /*handle*/ uint64_t uniffi_nobodywho_uniffi_fn_func_load_model(
-    RustBuffer model_path, int8_t use_gpu, RustBuffer projection_model_path);
+    RustBuffer model_path, int8_t use_gpu, RustBuffer projection_model_path,
+    RustBuffer on_download_progress);
 /*handle*/ uint64_t uniffi_nobodywho_uniffi_fn_func_sampler_preset_default(
     RustCallStatus *uniffi_out_err);
 /*handle*/ uint64_t uniffi_nobodywho_uniffi_fn_func_sampler_preset_dry(
@@ -452,6 +464,8 @@ uint16_t uniffi_nobodywho_uniffi_checksum_constructor_rusttool_new();
 uint16_t uniffi_nobodywho_uniffi_checksum_constructor_rusttool_new_async();
 uint16_t uniffi_nobodywho_uniffi_checksum_constructor_samplerbuilder_new();
 uint16_t uniffi_nobodywho_uniffi_checksum_constructor_samplerconfig_from_json();
+uint16_t
+uniffi_nobodywho_uniffi_checksum_method_rustdownloadprogresscallback_on_download_progress();
 uint16_t uniffi_nobodywho_uniffi_checksum_method_rusttoolcallback_call();
 uint32_t ffi_nobodywho_uniffi_uniffi_contract_version();
 }
@@ -890,6 +904,119 @@ static void cleanup() {
 } // namespace uniffi::nobodywho::cb::foreignfuturedroppedcallback
   // Implementation of free callback function CallbackInterfaceFree
 
+// Callback function:
+// uniffi::nobodywho::st::vtablecallbackinterfacerustdownloadprogresscallback::vtablecallbackinterfacerustdownloadprogresscallback::free::UniffiCallbackInterfaceFree
+//
+// We have the following constraints:
+// - we need to pass a function pointer to Rust.
+// - we need a jsi::Runtime and jsi::Function to call into JS.
+// - function pointers can't store state, so we can't use a lamda.
+//
+// For this, we store a lambda as a global, as `rsLambda`. The `callback`
+// function calls the lambda, which itself calls the `body` which then calls
+// into JS.
+//
+// We then give the `callback` function pointer to Rust which will call the
+// lambda sometime in the future.
+namespace uniffi::nobodywho::st::
+    vtablecallbackinterfacerustdownloadprogresscallback::
+        vtablecallbackinterfacerustdownloadprogresscallback::free {
+using namespace facebook;
+
+// We need to store a lambda in a global so we can call it from
+// a function pointer. The function pointer is passed to Rust.
+static std::function<void(uint64_t)> rsLambda = nullptr;
+
+// This is the main body of the callback. It's called from the lambda,
+// which itself is called from the callback function which is passed to Rust.
+static void body(jsi::Runtime &rt,
+                 std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
+                 std::shared_ptr<jsi::Value> callbackValue,
+                 uint64_t rs_handle) {
+
+  // Convert the arguments from Rust, into jsi::Values.
+  // We'll use the Bridging class to do this…
+  auto js_handle =
+      uniffi_jsi::Bridging<uint64_t>::toJs(rt, callInvoker, rs_handle);
+
+  // Now we are ready to call the callback.
+  // We are already on the JS thread, because this `body` function was
+  // invoked from the CallInvoker.
+  try {
+    // Getting the callback function
+    auto cb = callbackValue->asObject(rt).asFunction(rt);
+    auto uniffiResult = cb.call(rt, js_handle);
+
+  } catch (const jsi::JSError &error) {
+    std::cout << "Error in callback UniffiCallbackInterfaceFree: "
+              << error.what() << std::endl;
+    throw error;
+  }
+}
+
+static void callback(uint64_t rs_handle) {
+  // If the runtime has shutdown, then there is no point in trying to
+  // call into Javascript. BUT how do we tell if the runtime has shutdown?
+  //
+  // Answer: the module destructor calls into callback `cleanup` method,
+  // which nulls out the rsLamda.
+  //
+  // If rsLamda is null, then there is no runtime to call into.
+  if (rsLambda == nullptr) {
+    // This only occurs when destructors are calling into Rust free/drop,
+    // which causes the JS callback to be dropped.
+    return;
+  }
+
+  // The runtime, the actual callback jsi::funtion, and the callInvoker
+  // are all in the lambda.
+  rsLambda(rs_handle);
+}
+
+[[maybe_unused]] static UniffiCallbackInterfaceFree
+makeCallbackFunction( // uniffi::nobodywho::st::vtablecallbackinterfacerustdownloadprogresscallback::vtablecallbackinterfacerustdownloadprogresscallback::free
+    jsi::Runtime &rt,
+    std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
+    const jsi::Value &value) {
+  if (rsLambda != nullptr) {
+    // `makeCallbackFunction` is called in two circumstances:
+    //
+    // 1. at startup, when initializing callback interface vtables.
+    // 2. when polling futures. This happens at least once per future that is
+    //    exposed to Javascript. We know that this is always the same function,
+    //    `uniffiFutureContinuationCallback` in `async-rust-calls.ts`.
+    //
+    // We can therefore return the callback function without making anything
+    // new if we've been initialized already.
+    return callback;
+  }
+  auto callbackFunction = value.asObject(rt).asFunction(rt);
+  auto callbackValue = std::make_shared<jsi::Value>(rt, callbackFunction);
+  rsLambda = [&rt, callInvoker, callbackValue](uint64_t rs_handle) {
+    // We immediately make a lambda which will do the work of transforming the
+    // arguments into JSI values and calling the callback.
+    uniffi_runtime::UniffiCallFunc jsLambda =
+        [callInvoker, callbackValue, rs_handle](jsi::Runtime &rt) mutable {
+          body(rt, callInvoker, callbackValue, rs_handle);
+        };
+    // We'll then call that lambda from the callInvoker which will
+    // look after calling it on the correct thread.
+
+    callInvoker->invokeNonBlocking(rt, jsLambda);
+  };
+  return callback;
+}
+
+// This method is called from the destructor of NativeNobodywho, which only
+// happens when the jsi::Runtime is being destroyed.
+static void cleanup() {
+  // The lambda holds a reference to the the Runtime, so when this is nulled
+  // out, then the pointer will no longer be left dangling.
+  rsLambda = nullptr;
+}
+} // namespace
+  // uniffi::nobodywho::st::vtablecallbackinterfacerustdownloadprogresscallback::vtablecallbackinterfacerustdownloadprogresscallback::free
+
 // Callback function:
 // uniffi::nobodywho::st::vtablecallbackinterfacerusttoolcallback::vtablecallbackinterfacerusttoolcallback::free::UniffiCallbackInterfaceFree
 //
@@ -1822,6 +1949,314 @@ template <> struct Bridging<UniffiForeignFutureCompleteVoid> {
     return jsi::Value::undefined();
   }
 };
+} // namespace uniffi::nobodywho
+  // Implementation of CallbackInterfaceClone for vtable field uniffi_clone in
+  // VTableCallbackInterfaceRustDownloadProgressCallback
+
+// Callback function:
+// uniffi::nobodywho::cb::callbackinterfaceclone::vtablecallbackinterfacerustdownloadprogresscallback::UniffiCallbackInterfaceClone
+//
+// We have the following constraints:
+// - we need to pass a function pointer to Rust.
+// - we need a jsi::Runtime and jsi::Function to call into JS.
+// - function pointers can't store state, so we can't use a lamda.
+//
+// For this, we store a lambda as a global, as `rsLambda`. The `callback`
+// function calls the lambda, which itself calls the `body` which then calls
+// into JS.
+//
+// We then give the `callback` function pointer to Rust which will call the
+// lambda sometime in the future.
+namespace uniffi::nobodywho::cb::callbackinterfaceclone::
+    vtablecallbackinterfacerustdownloadprogresscallback {
+using namespace facebook;
+
+// We need to store a lambda in a global so we can call it from
+// a function pointer. The function pointer is passed to Rust.
+static std::function<void(uint64_t, uint64_t *)> rsLambda = nullptr;
+
+// This is the main body of the callback. It's called from the lambda,
+// which itself is called from the callback function which is passed to Rust.
+static void body(jsi::Runtime &rt,
+                 std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
+                 std::shared_ptr<jsi::Value> callbackValue, uint64_t rs_handle,
+                 uint64_t *uniffi_direct_return) {
+
+  // Convert the arguments from Rust, into jsi::Values.
+  // We'll use the Bridging class to do this…
+  auto js_handle =
+      uniffi_jsi::Bridging<uint64_t>::toJs(rt, callInvoker, rs_handle);
+
+  // Now we are ready to call the callback.
+  // We are already on the JS thread, because this `body` function was
+  // invoked from the CallInvoker.
+  try {
+    // Getting the callback function
+    auto cb = callbackValue->asObject(rt).asFunction(rt);
+    auto uniffiResult = cb.call(rt, js_handle);
+
+    // Write the direct return value back to the caller.
+    if (uniffi_direct_return != nullptr) {
+      *uniffi_direct_return =
+          uniffi_jsi::Bridging<uint64_t>::fromJs(rt, callInvoker, uniffiResult);
+    }
+  } catch (const jsi::JSError &error) {
+    std::cout << "Error in callback UniffiCallbackInterfaceClone: "
+              << error.what() << std::endl;
+    throw error;
+  }
+}
+
+static uint64_t callback(uint64_t rs_handle) {
+  // If the runtime has shutdown, then there is no point in trying to
+  // call into Javascript. BUT how do we tell if the runtime has shutdown?
+  //
+  // Answer: the module destructor calls into callback `cleanup` method,
+  // which nulls out the rsLamda.
+  //
+  // If rsLamda is null, then there is no runtime to call into.
+  if (rsLambda == nullptr) {
+    // This only occurs when destructors are calling into Rust free/drop,
+    // which causes the JS callback to be dropped.
+    return 0;
+  }
+  uint64_t uniffi_result = 0;
+
+  // The runtime, the actual callback jsi::funtion, and the callInvoker
+  // are all in the lambda.
+  rsLambda(rs_handle, &uniffi_result);
+  return uniffi_result;
+}
+
+[[maybe_unused]] static UniffiCallbackInterfaceClone
+makeCallbackFunction( // uniffi::nobodywho::cb::callbackinterfaceclone::vtablecallbackinterfacerustdownloadprogresscallback
+    jsi::Runtime &rt,
+    std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
+    const jsi::Value &value) {
+  if (rsLambda != nullptr) {
+    // `makeCallbackFunction` is called in two circumstances:
+    //
+    // 1. at startup, when initializing callback interface vtables.
+    // 2. when polling futures. This happens at least once per future that is
+    //    exposed to Javascript. We know that this is always the same function,
+    //    `uniffiFutureContinuationCallback` in `async-rust-calls.ts`.
+    //
+    // We can therefore return the callback function without making anything
+    // new if we've been initialized already.
+    return callback;
+  }
+  auto callbackFunction = value.asObject(rt).asFunction(rt);
+  auto callbackValue = std::make_shared<jsi::Value>(rt, callbackFunction);
+  rsLambda = [&rt, callInvoker, callbackValue](uint64_t rs_handle,
+                                               uint64_t *uniffi_direct_return) {
+    // We immediately make a lambda which will do the work of transforming the
+    // arguments into JSI values and calling the callback.
+    uniffi_runtime::UniffiCallFunc jsLambda =
+        [callInvoker, callbackValue, rs_handle,
+         uniffi_direct_return](jsi::Runtime &rt) mutable {
+          body(rt, callInvoker, callbackValue, rs_handle, uniffi_direct_return);
+        };
+    // We'll then call that lambda from the callInvoker which will
+    // look after calling it on the correct thread.
+    callInvoker->invokeBlocking(rt, jsLambda);
+  };
+  return callback;
+}
+
+// This method is called from the destructor of NativeNobodywho, which only
+// happens when the jsi::Runtime is being destroyed.
+static void cleanup() {
+  // The lambda holds a reference to the the Runtime, so when this is nulled
+  // out, then the pointer will no longer be left dangling.
+  rsLambda = nullptr;
+}
+} // namespace
+  // uniffi::nobodywho::cb::callbackinterfaceclone::vtablecallbackinterfacerustdownloadprogresscallback
+  // Implementation of CallbackInterfaceRustDownloadProgressCallbackMethod0 for
+  // vtable field on_download_progress in
+  // VTableCallbackInterfaceRustDownloadProgressCallback
+
+// Callback function:
+// uniffi::nobodywho::cb::callbackinterfacerustdownloadprogresscallbackmethod0::vtablecallbackinterfacerustdownloadprogresscallback::UniffiCallbackInterfaceRustDownloadProgressCallbackMethod0
+//
+// We have the following constraints:
+// - we need to pass a function pointer to Rust.
+// - we need a jsi::Runtime and jsi::Function to call into JS.
+// - function pointers can't store state, so we can't use a lamda.
+//
+// For this, we store a lambda as a global, as `rsLambda`. The `callback`
+// function calls the lambda, which itself calls the `body` which then calls
+// into JS.
+//
+// We then give the `callback` function pointer to Rust which will call the
+// lambda sometime in the future.
+namespace uniffi::nobodywho::cb::
+    callbackinterfacerustdownloadprogresscallbackmethod0::
+        vtablecallbackinterfacerustdownloadprogresscallback {
+using namespace facebook;
+
+// We need to store a lambda in a global so we can call it from
+// a function pointer. The function pointer is passed to Rust.
+static std::function<void(uint64_t, uint64_t, uint64_t, void *,
+                          RustCallStatus *)>
+    rsLambda = nullptr;
+
+// This is the main body of the callback. It's called from the lambda,
+// which itself is called from the callback function which is passed to Rust.
+static void body(jsi::Runtime &rt,
+                 std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
+                 std::shared_ptr<jsi::Value> callbackValue,
+                 uint64_t rs_uniffiHandle, uint64_t rs_downloaded,
+                 uint64_t rs_total, void *rs_uniffiOutReturn,
+                 RustCallStatus *uniffi_call_status) {
+
+  // Convert the arguments from Rust, into jsi::Values.
+  // We'll use the Bridging class to do this…
+  auto js_uniffiHandle =
+      uniffi_jsi::Bridging<uint64_t>::toJs(rt, callInvoker, rs_uniffiHandle);
+  auto js_downloaded =
+      uniffi_jsi::Bridging<uint64_t>::toJs(rt, callInvoker, rs_downloaded);
+  auto js_total =
+      uniffi_jsi::Bridging<uint64_t>::toJs(rt, callInvoker, rs_total);
+
+  // Now we are ready to call the callback.
+  // We are already on the JS thread, because this `body` function was
+  // invoked from the CallInvoker.
+  try {
+    // Getting the callback function
+    auto cb = callbackValue->asObject(rt).asFunction(rt);
+    auto uniffiResult = cb.call(rt, js_uniffiHandle, js_downloaded, js_total);
+
+    // Now copy the result back from JS into the RustCallStatus object.
+    uniffi::nobodywho::Bridging<RustCallStatus>::copyFromJs(
+        rt, callInvoker, uniffiResult, uniffi_call_status);
+
+    if (uniffi_call_status->code != UNIFFI_CALL_STATUS_OK) {
+      // The JS callback finished abnormally, so we cannot retrieve the return
+      // value.
+      return;
+    }
+
+  } catch (const jsi::JSError &error) {
+    std::cout << "Error in callback "
+                 "UniffiCallbackInterfaceRustDownloadProgressCallbackMethod0: "
+              << error.what() << std::endl;
+    throw error;
+  }
+}
+
+static void callback(uint64_t rs_uniffiHandle, uint64_t rs_downloaded,
+                     uint64_t rs_total, void *rs_uniffiOutReturn,
+                     RustCallStatus *uniffi_call_status) {
+  // If the runtime has shutdown, then there is no point in trying to
+  // call into Javascript. BUT how do we tell if the runtime has shutdown?
+  //
+  // Answer: the module destructor calls into callback `cleanup` method,
+  // which nulls out the rsLamda.
+  //
+  // If rsLamda is null, then there is no runtime to call into.
+  if (rsLambda == nullptr) {
+    // This only occurs when destructors are calling into Rust free/drop,
+    // which causes the JS callback to be dropped.
+    return;
+  }
+
+  // The runtime, the actual callback jsi::funtion, and the callInvoker
+  // are all in the lambda.
+  rsLambda(rs_uniffiHandle, rs_downloaded, rs_total, rs_uniffiOutReturn,
+           uniffi_call_status);
+}
+
+[[maybe_unused]] static UniffiCallbackInterfaceRustDownloadProgressCallbackMethod0
+makeCallbackFunction( // uniffi::nobodywho::cb::callbackinterfacerustdownloadprogresscallbackmethod0::vtablecallbackinterfacerustdownloadprogresscallback
+    jsi::Runtime &rt,
+    std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
+    const jsi::Value &value) {
+  if (rsLambda != nullptr) {
+    // `makeCallbackFunction` is called in two circumstances:
+    //
+    // 1. at startup, when initializing callback interface vtables.
+    // 2. when polling futures. This happens at least once per future that is
+    //    exposed to Javascript. We know that this is always the same function,
+    //    `uniffiFutureContinuationCallback` in `async-rust-calls.ts`.
+    //
+    // We can therefore return the callback function without making anything
+    // new if we've been initialized already.
+    return callback;
+  }
+  auto callbackFunction = value.asObject(rt).asFunction(rt);
+  auto callbackValue = std::make_shared<jsi::Value>(rt, callbackFunction);
+  rsLambda = [&rt, callInvoker,
+              callbackValue](uint64_t rs_uniffiHandle, uint64_t rs_downloaded,
+                             uint64_t rs_total, void *rs_uniffiOutReturn,
+                             RustCallStatus *uniffi_call_status) {
+    // We immediately make a lambda which will do the work of transforming the
+    // arguments into JSI values and calling the callback.
+    uniffi_runtime::UniffiCallFunc jsLambda =
+        [callInvoker, callbackValue, rs_uniffiHandle, rs_downloaded, rs_total,
+         rs_uniffiOutReturn, uniffi_call_status](jsi::Runtime &rt) mutable {
+          body(rt, callInvoker, callbackValue, rs_uniffiHandle, rs_downloaded,
+               rs_total, rs_uniffiOutReturn, uniffi_call_status);
+        };
+    // We'll then call that lambda from the callInvoker which will
+    // look after calling it on the correct thread.
+    callInvoker->invokeBlocking(rt, jsLambda);
+  };
+  return callback;
+}
+
+// This method is called from the destructor of NativeNobodywho, which only
+// happens when the jsi::Runtime is being destroyed.
+static void cleanup() {
+  // The lambda holds a reference to the the Runtime, so when this is nulled
+  // out, then the pointer will no longer be left dangling.
+  rsLambda = nullptr;
+}
+} // namespace
+  // uniffi::nobodywho::cb::callbackinterfacerustdownloadprogresscallbackmethod0::vtablecallbackinterfacerustdownloadprogresscallback
+namespace uniffi::nobodywho {
+using namespace facebook;
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <>
+struct Bridging<UniffiVTableCallbackInterfaceRustDownloadProgressCallback> {
+  static UniffiVTableCallbackInterfaceRustDownloadProgressCallback
+  fromJs(jsi::Runtime &rt, std::shared_ptr<CallInvoker> callInvoker,
+         const jsi::Value &jsValue) {
+    // Check if the input is an object
+    if (!jsValue.isObject()) {
+      throw jsi::JSError(
+          rt, "Expected an object for "
+              "UniffiVTableCallbackInterfaceRustDownloadProgressCallback");
+    }
+
+    // Get the object from the jsi::Value
+    auto jsObject = jsValue.getObject(rt);
+
+    // Create the vtable struct
+    UniffiVTableCallbackInterfaceRustDownloadProgressCallback rsObject;
+
+    // Create the vtable from the js callbacks.
+    rsObject.uniffi_free = uniffi::nobodywho::st::
+        vtablecallbackinterfacerustdownloadprogresscallback::
+            vtablecallbackinterfacerustdownloadprogresscallback::free::
+                makeCallbackFunction(rt, callInvoker,
+                                     jsObject.getProperty(rt, "uniffiFree"));
+    rsObject.uniffi_clone = uniffi::nobodywho::cb::callbackinterfaceclone::
+        vtablecallbackinterfacerustdownloadprogresscallback::
+            makeCallbackFunction(rt, callInvoker,
+                                 jsObject.getProperty(rt, "uniffiClone"));
+    rsObject.on_download_progress = uniffi::nobodywho::cb::
+        callbackinterfacerustdownloadprogresscallbackmethod0::
+            vtablecallbackinterfacerustdownloadprogresscallback::
+                makeCallbackFunction(
+                    rt, callInvoker,
+                    jsObject.getProperty(rt, "onDownloadProgress"));
+
+    return rsObject;
+  }
+};
+
 } // namespace uniffi::nobodywho
   // Implementation of CallbackInterfaceClone for vtable field uniffi_clone in
   // VTableCallbackInterfaceRustToolCallback
@@ -2886,6 +3321,19 @@ NativeNobodywho::NativeNobodywho(
                 ->cpp_uniffi_nobodywho_uniffi_fn_method_samplerconfig_to_json(
                     rt, thisVal, args, count);
           });
+  props["ubrn_uniffi_nobodywho_uniffi_fn_init_callback_vtable_"
+        "rustdownloadprogresscallback"] = jsi::Function::createFromHostFunction(
+      rt,
+      jsi::PropNameID::forAscii(rt,
+                                "ubrn_uniffi_nobodywho_uniffi_fn_init_callback_"
+                                "vtable_rustdownloadprogresscallback"),
+      1,
+      [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+             const jsi::Value *args, size_t count) -> jsi::Value {
+        return this
+            ->cpp_uniffi_nobodywho_uniffi_fn_init_callback_vtable_rustdownloadprogresscallback(
+                rt, thisVal, args, count);
+      });
   props["ubrn_uniffi_nobodywho_uniffi_fn_init_callback_vtable_"
         "rusttoolcallback"] = jsi::Function::createFromHostFunction(
       rt,
@@ -2914,7 +3362,7 @@ NativeNobodywho::NativeNobodywho(
           rt,
           jsi::PropNameID::forAscii(
               rt, "ubrn_uniffi_nobodywho_uniffi_fn_func_load_model"),
-          3,
+          4,
           [this](jsi::Runtime &rt, const jsi::Value &thisVal,
                  const jsi::Value *args, size_t count) -> jsi::Value {
             return this->cpp_uniffi_nobodywho_uniffi_fn_func_load_model(
@@ -4188,6 +4636,20 @@ NativeNobodywho::NativeNobodywho(
             ->cpp_uniffi_nobodywho_uniffi_checksum_constructor_samplerconfig_from_json(
                 rt, thisVal, args, count);
       });
+  props["ubrn_uniffi_nobodywho_uniffi_checksum_method_"
+        "rustdownloadprogresscallback_on_download_progress"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_nobodywho_uniffi_checksum_method_"
+                  "rustdownloadprogresscallback_on_download_progress"),
+          0,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this
+                ->cpp_uniffi_nobodywho_uniffi_checksum_method_rustdownloadprogresscallback_on_download_progress(
+                    rt, thisVal, args, count);
+          });
   props["ubrn_uniffi_nobodywho_uniffi_checksum_method_rusttoolcallback_call"] =
       jsi::Function::createFromHostFunction(
           rt,
@@ -4352,8 +4814,14 @@ NativeNobodywho::~NativeNobodywho() {
   // Cleanup for callback function ForeignFutureDroppedCallback
   uniffi::nobodywho::cb::foreignfuturedroppedcallback::cleanup();
   // Cleanup for "free" callback function CallbackInterfaceFree
+  uniffi::nobodywho::st::vtablecallbackinterfacerustdownloadprogresscallback::
+      vtablecallbackinterfacerustdownloadprogresscallback::free::cleanup();
   uniffi::nobodywho::st::vtablecallbackinterfacerusttoolcallback::
       vtablecallbackinterfacerusttoolcallback::free::cleanup();
+  uniffi::nobodywho::cb::callbackinterfaceclone::
+      vtablecallbackinterfacerustdownloadprogresscallback::cleanup();
+  uniffi::nobodywho::cb::callbackinterfacerustdownloadprogresscallbackmethod0::
+      vtablecallbackinterfacerustdownloadprogresscallback::cleanup();
   uniffi::nobodywho::cb::callbackinterfaceclone::
       vtablecallbackinterfacerusttoolcallback::cleanup();
   uniffi::nobodywho::cb::callbackinterfacerusttoolcallbackmethod0::
@@ -5395,6 +5863,21 @@ NativeNobodywho::cpp_uniffi_nobodywho_uniffi_fn_method_samplerconfig_to_json(
 
   return uniffi::nobodywho::Bridging<RustBuffer>::toJs(rt, callInvoker, value);
 }
+jsi::Value NativeNobodywho::
+    cpp_uniffi_nobodywho_uniffi_fn_init_callback_vtable_rustdownloadprogresscallback(
+        jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+        size_t count) {
+  auto vtableInstance = uniffi::nobodywho::Bridging<
+      UniffiVTableCallbackInterfaceRustDownloadProgressCallback>::
+      fromJs(rt, callInvoker, args[0]);
+
+  std::lock_guard<std::mutex> lock(uniffi::nobodywho::registry::vtableMutex);
+  uniffi_nobodywho_uniffi_fn_init_callback_vtable_rustdownloadprogresscallback(
+      uniffi::nobodywho::registry::putTable(
+          "UniffiVTableCallbackInterfaceRustDownloadProgressCallback",
+          vtableInstance));
+  return jsi::Value::undefined();
+}
 jsi::Value NativeNobodywho::
     cpp_uniffi_nobodywho_uniffi_fn_init_callback_vtable_rusttoolcallback(
         jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
@@ -5430,8 +5913,9 @@ jsi::Value NativeNobodywho::cpp_uniffi_nobodywho_uniffi_fn_func_load_model(
   auto value = uniffi_nobodywho_uniffi_fn_func_load_model(
       uniffi::nobodywho::Bridging<RustBuffer>::fromJs(rt, callInvoker, args[0]),
       uniffi_jsi::Bridging<int8_t>::fromJs(rt, callInvoker, args[1]),
+      uniffi::nobodywho::Bridging<RustBuffer>::fromJs(rt, callInvoker, args[2]),
       uniffi::nobodywho::Bridging<RustBuffer>::fromJs(rt, callInvoker,
-                                                      args[2]));
+                                                      args[3]));
 
   return uniffi_jsi::Bridging</*handle*/ uint64_t>::toJs(rt, callInvoker,
                                                          value);
@@ -6539,6 +7023,15 @@ jsi::Value NativeNobodywho::
 
   return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
 }
+jsi::Value NativeNobodywho::
+    cpp_uniffi_nobodywho_uniffi_checksum_method_rustdownloadprogresscallback_on_download_progress(
+        jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+        size_t count) {
+  auto value =
+      uniffi_nobodywho_uniffi_checksum_method_rustdownloadprogresscallback_on_download_progress();
+
+  return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
+}
 jsi::Value NativeNobodywho::
     cpp_uniffi_nobodywho_uniffi_checksum_method_rusttoolcallback_call(
         jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,

package/generated/cpp/nobodywho.hpp

@@ -211,6 +211,10 @@ protected:
       jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
       size_t count);
   jsi::Value
+  cpp_uniffi_nobodywho_uniffi_fn_init_callback_vtable_rustdownloadprogresscallback(
+      jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+      size_t count);
+  jsi::Value
   cpp_uniffi_nobodywho_uniffi_fn_init_callback_vtable_rusttoolcallback(
       jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
       size_t count);
@@ -573,6 +577,10 @@ protected:
   cpp_uniffi_nobodywho_uniffi_checksum_constructor_samplerconfig_from_json(
       jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
       size_t count);
+  jsi::Value
+  cpp_uniffi_nobodywho_uniffi_checksum_method_rustdownloadprogresscallback_on_download_progress(
+      jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+      size_t count);
   jsi::Value cpp_uniffi_nobodywho_uniffi_checksum_method_rusttoolcallback_call(
       jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
       size_t count);

package/generated/ts/nobodywho-ffi.ts

@@ -77,9 +77,10 @@ interface NativeModuleInterface {
     ubrn_uniffi_nobodywho_uniffi_fn_free_samplerconfig(handle: bigint, uniffi_out_err: UniffiRustCallStatus): void;
     ubrn_uniffi_nobodywho_uniffi_fn_constructor_samplerconfig_from_json(jsonStr: Uint8Array, uniffi_out_err: UniffiRustCallStatus): bigint;
     ubrn_uniffi_nobodywho_uniffi_fn_method_samplerconfig_to_json(ptr: bigint, uniffi_out_err: UniffiRustCallStatus): Uint8Array;
+    ubrn_uniffi_nobodywho_uniffi_fn_init_callback_vtable_rustdownloadprogresscallback(vtable: UniffiVTableCallbackInterfaceRustDownloadProgressCallback): void;
     ubrn_uniffi_nobodywho_uniffi_fn_init_callback_vtable_rusttoolcallback(vtable: UniffiVTableCallbackInterfaceRustToolCallback): void;
     ubrn_uniffi_nobodywho_uniffi_fn_func_cosine_similarity(a: Uint8Array, b: Uint8Array, uniffi_out_err: UniffiRustCallStatus): number;
-    ubrn_uniffi_nobodywho_uniffi_fn_func_load_model(modelPath: Uint8Array, useGpu: number, projectionModelPath: Uint8Array): bigint;
+    ubrn_uniffi_nobodywho_uniffi_fn_func_load_model(modelPath: Uint8Array, useGpu: number, projectionModelPath: Uint8Array, onDownloadProgress: Uint8Array): bigint;
     ubrn_uniffi_nobodywho_uniffi_fn_func_sampler_preset_default(uniffi_out_err: UniffiRustCallStatus): bigint;
     ubrn_uniffi_nobodywho_uniffi_fn_func_sampler_preset_dry(uniffi_out_err: UniffiRustCallStatus): bigint;
     ubrn_uniffi_nobodywho_uniffi_fn_func_sampler_preset_grammar(grammar: Uint8Array, uniffi_out_err: UniffiRustCallStatus): bigint;
@@ -189,6 +190,7 @@ interface NativeModuleInterface {
     ubrn_uniffi_nobodywho_uniffi_checksum_constructor_rusttool_new_async(): number;
     ubrn_uniffi_nobodywho_uniffi_checksum_constructor_samplerbuilder_new(): number;
     ubrn_uniffi_nobodywho_uniffi_checksum_constructor_samplerconfig_from_json(): number;
+    ubrn_uniffi_nobodywho_uniffi_checksum_method_rustdownloadprogresscallback_on_download_progress(): number;
     ubrn_uniffi_nobodywho_uniffi_checksum_method_rusttoolcallback_call(): number;
     ubrn_ffi_nobodywho_uniffi_uniffi_contract_version(): number;
     ubrn_uniffi_internal_fn_method_rustchat_ffi__bless_pointer(pointer: bigint, uniffi_out_err: UniffiRustCallStatus): UniffiGcObject;
@@ -278,8 +280,15 @@ export type UniffiForeignFutureResultVoid = {
   callStatus: UniffiRustCallStatus;
 };
 export type UniffiForeignFutureCompleteVoid = (callbackData: bigint, result: UniffiForeignFutureResultVoid) => void;
+type UniffiCallbackInterfaceRustDownloadProgressCallbackMethod0 = (uniffiHandle: bigint, downloaded: bigint, total: bigint) => UniffiResult<void>
+;
 type UniffiCallbackInterfaceRustToolCallbackMethod0 = (uniffiHandle: bigint, argumentsJson: Uint8Array) => Uint8Array
 ;
+export type UniffiVTableCallbackInterfaceRustDownloadProgressCallback = {
+  uniffiFree: UniffiCallbackInterfaceFree;
+  uniffiClone: UniffiCallbackInterfaceClone;
+  onDownloadProgress: UniffiCallbackInterfaceRustDownloadProgressCallbackMethod0;
+};
 export type UniffiVTableCallbackInterfaceRustToolCallback = {
   uniffiFree: UniffiCallbackInterfaceFree;
   uniffiClone: UniffiCallbackInterfaceClone;

package/generated/ts/nobodywho.ts

@@ -32,6 +32,7 @@ import nativeModule, {
   type UniffiForeignFutureCompleteRustBuffer,
   type UniffiForeignFutureResultVoid,
   type UniffiForeignFutureCompleteVoid,
+  type UniffiVTableCallbackInterfaceRustDownloadProgressCallback,
   type UniffiVTableCallbackInterfaceRustToolCallback,
 } from "./nobodywho-ffi";
 import {
@@ -104,13 +105,13 @@ export function cosineSimilarity(a: Array</*f32*/number>, b: Array</*f32*/number
  * uniffi-bindgen-react-native generates invalid JS (`async static` instead
  * of `static async`) for async constructors.
  */
-export async function loadModel(modelPath: string, useGpu: boolean, projectionModelPath: string | undefined, asyncOpts_?: { signal: AbortSignal }): Promise<RustModelInterface> /*throws*/ {
+export async function loadModel(modelPath: string, useGpu: boolean, projectionModelPath: string | undefined, onDownloadProgress: RustDownloadProgressCallback | undefined, asyncOpts_?: { signal: AbortSignal }): Promise<RustModelInterface> /*throws*/ {
     const __stack = uniffiIsDebug ? new Error().stack : undefined;
     try {
         return await uniffiRustCallAsync(
             /*rustCaller:*/ uniffiCaller,
             /*rustFutureFunc:*/ () => {
-                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_func_load_model(FfiConverterString.lower(modelPath),FfiConverterBool.lower(useGpu),FfiConverterOptionalString.lower(projectionModelPath)
+                return nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_func_load_model(FfiConverterString.lower(modelPath),FfiConverterBool.lower(useGpu),FfiConverterOptionalString.lower(projectionModelPath),FfiConverterOptionalTypeRustDownloadProgressCallback.lower(onDownloadProgress)
                 );
             },
             /*pollFunc:*/ nativeModule().ubrn_ffi_nobodywho_uniffi_rust_future_poll_u64,
@@ -234,6 +235,69 @@ export function samplerPresetTopP(topP: /*f32*/number): SamplerConfigInterface {
 
 
 
+/**
+ * Callback interface for download progress reporting. Implement this in your
+ * language to receive `(downloadedBytes, totalBytes)` events while a remote
+ * model is being downloaded. Throttled to ~10 Hz with a guaranteed final emit
+ * on completion. Not invoked for cached/local files.
+ */
+export interface RustDownloadProgressCallback {
+    
+    onDownloadProgress(downloaded: /*u64*/bigint, total: /*u64*/bigint) : void;
+}
+
+
+// Put the implementation in a struct so we don't pollute the top-level namespace
+const uniffiCallbackInterfaceRustDownloadProgressCallback: { vtable: UniffiVTableCallbackInterfaceRustDownloadProgressCallback; register: () => void; } = {
+    // Create the VTable using a series of closures.
+    // ts automatically converts these into C callback functions.
+    vtable: {
+        onDownloadProgress: (
+            uniffiHandle: bigint,
+            downloaded: bigint,
+            total: bigint,) => {
+            const uniffiMakeCall = 
+            ()
+            : void => {
+                const jsCallback = FfiConverterTypeRustDownloadProgressCallback.lift(uniffiHandle);
+                return jsCallback.onDownloadProgress(
+                    FfiConverterUInt64.lift(downloaded), 
+                    FfiConverterUInt64.lift(total)
+                )
+            };
+            const uniffiResult = UniffiResult.ready<void>();
+            const uniffiHandleSuccess = (obj: any) => {};
+            const uniffiHandleError = (code: number, errBuf: UniffiByteArray) => {
+                UniffiResult.writeError(uniffiResult, code, errBuf);
+            };
+            uniffiTraitInterfaceCall(
+                /*makeCall:*/ uniffiMakeCall,
+                /*handleSuccess:*/ uniffiHandleSuccess,
+                /*handleError:*/ uniffiHandleError,
+                /*lowerString:*/ FfiConverterString.lower
+            )
+            return uniffiResult;
+        },
+        uniffiFree: (uniffiHandle: UniffiHandle): void => {
+            // RustDownloadProgressCallback: this will throw a stale handle error if the handle isn't found.
+            FfiConverterTypeRustDownloadProgressCallback.drop(uniffiHandle);
+        },
+        uniffiClone: (uniffiHandle: UniffiHandle): UniffiHandle => {
+            return FfiConverterTypeRustDownloadProgressCallback.clone(uniffiHandle);
+        }
+    },
+    register: () => {
+        nativeModule().ubrn_uniffi_nobodywho_uniffi_fn_init_callback_vtable_rustdownloadprogresscallback(
+            uniffiCallbackInterfaceRustDownloadProgressCallback.vtable
+        );
+    },
+};
+
+// FfiConverter protocol for callback interfaces
+const FfiConverterTypeRustDownloadProgressCallback = new FfiConverterCallback<RustDownloadProgressCallback>();
+
+
+
 /**
  * Callback interface for tool functions.
  * Implement this in your language to provide the tool's logic.
@@ -2891,6 +2955,10 @@ const uniffiTypeSamplerConfigObjectFactory: UniffiObjectFactory<SamplerConfigInt
 const FfiConverterTypeSamplerConfig =  new FfiConverterObject(uniffiTypeSamplerConfigObjectFactory);
 
 
+// FfiConverter for RustDownloadProgressCallback | undefined
+const FfiConverterOptionalTypeRustDownloadProgressCallback = new FfiConverterOptional(FfiConverterTypeRustDownloadProgressCallback);
+
+
 // FfiConverter for PendingToolCall | undefined
 const FfiConverterOptionalTypePendingToolCall = new FfiConverterOptional(FfiConverterTypePendingToolCall);
 
@@ -2967,7 +3035,7 @@ function uniffiEnsureInitialized() {
     if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_func_cosine_similarity() !== 63439) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_func_cosine_similarity");
     }
-    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_func_load_model() !== 63144) {
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_func_load_model() !== 33587) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_func_load_model");
     }
     if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_func_sampler_preset_default() !== 10834) {
@@ -3123,10 +3191,14 @@ function uniffiEnsureInitialized() {
     if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_constructor_samplerconfig_from_json() !== 6867) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_constructor_samplerconfig_from_json");
     }
+    if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rustdownloadprogresscallback_on_download_progress() !== 28617) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rustdownloadprogresscallback_on_download_progress");
+    }
     if (nativeModule().ubrn_uniffi_nobodywho_uniffi_checksum_method_rusttoolcallback_call() !== 43958) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_nobodywho_uniffi_checksum_method_rusttoolcallback_call");
     }
 
+    uniffiCallbackInterfaceRustDownloadProgressCallback.register();
     uniffiCallbackInterfaceRustToolCallback.register();
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nobodywho",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Run LLMs locally with offline inference — React Native bindings",
   "main": "src/wrapper.ts",
   "types": "src/wrapper.ts",

package/src/chat.ts

@@ -69,11 +69,13 @@ export class Chat {
     templateVariables?: Record<string, boolean>;
     tools?: Tool[];
     sampler?: SamplerConfig;
+    onDownloadProgress?: (downloaded: number, total: number) => void;
   }): Promise<Chat> {
     const model = await Model.load({
       modelPath: opts.modelPath,
       useGpu: opts.useGpu,
       projectionModelPath: opts.projectionModelPath,
+      onDownloadProgress: opts.onDownloadProgress,
     });
     return new Chat({ model, ...opts });
   }

package/src/cross_encoder.ts

@@ -35,8 +35,13 @@ export class CrossEncoder {
     modelPath: string;
     useGpu?: boolean;
     contextSize?: number;
+    onDownloadProgress?: (downloaded: number, total: number) => void;
   }): Promise<CrossEncoder> {
-    const model = await Model.load({ modelPath: opts.modelPath, useGpu: opts.useGpu });
+    const model = await Model.load({
+      modelPath: opts.modelPath,
+      useGpu: opts.useGpu,
+      onDownloadProgress: opts.onDownloadProgress,
+    });
     return new CrossEncoder({ model, ...opts });
   }
 

package/src/encoder.ts

@@ -31,8 +31,13 @@ export class Encoder {
     modelPath: string;
     useGpu?: boolean;
     contextSize?: number;
+    onDownloadProgress?: (downloaded: number, total: number) => void;
   }): Promise<Encoder> {
-    const model = await Model.load({ modelPath: opts.modelPath, useGpu: opts.useGpu });
+    const model = await Model.load({
+      modelPath: opts.modelPath,
+      useGpu: opts.useGpu,
+      onDownloadProgress: opts.onDownloadProgress,
+    });
     return new Encoder({ model, ...opts });
   }
 

package/src/model.ts

@@ -39,16 +39,23 @@ export class Model {
    * @param opts.modelPath - Path to the GGUF model file, or a `hf://owner/repo/file.gguf` / `https://` URL to download and cache automatically
    * @param opts.useGpu - Use GPU acceleration if available (default: true)
    * @param opts.projectionModelPath - Path to a multimodal projector file for vision models
+   * @param opts.onDownloadProgress - Invoked with `(downloaded, total)` byte counts while a remote model is being downloaded. Throttled to ~10 Hz with a guaranteed final emit on completion. Not invoked for cached/local files.
    */
   static async load(opts: {
     modelPath: string;
     useGpu?: boolean;
     projectionModelPath?: string;
+    onDownloadProgress?: (downloaded: number, total: number) => void;
   }): Promise<Model> {
+    const cb = opts.onDownloadProgress;
+    const progressCallback = cb
+      ? { onDownloadProgress: (d: bigint, t: bigint) => cb(Number(d), Number(t)) }
+      : undefined;
     const inner = await loadModel(
       opts.modelPath,
       opts.useGpu ?? true,
       opts.projectionModelPath,
+      progressCallback,
     );
     return new Model(inner);
   }