react-native-executorch 0.5.1 → 0.5.3

package/common/rnexecutorch/host_objects/ModelHostObject.h

@@ -1,6 +1,12 @@
 #pragma once
 
 #include <ReactCommon/CallInvoker.h>
+#include <sstream>
+#include <string>
+#include <thread>
+#include <tuple>
+#include <type_traits>
+
 #include <memory.h>
 #include <rnexecutorch/TokenizerModule.h>
 #include <rnexecutorch/host_objects/JSTensorViewOut.h>
@@ -10,12 +16,9 @@
 #include <rnexecutorch/metaprogramming/FunctionHelpers.h>
 #include <rnexecutorch/metaprogramming/TypeConcepts.h>
 #include <rnexecutorch/models/BaseModel.h>
+#include <rnexecutorch/models/llm/LLM.h>
 #include <rnexecutorch/models/ocr/OCR.h>
 #include <rnexecutorch/models/vertical_ocr/VerticalOCR.h>
-#include <string>
-#include <thread>
-#include <tuple>
-#include <type_traits>
 
 namespace rnexecutorch {
 
@@ -24,18 +27,18 @@ public:
   explicit ModelHostObject(const std::shared_ptr<Model> &model,
                            std::shared_ptr<react::CallInvoker> callInvoker)
       : model(model), callInvoker(callInvoker) {
-    if constexpr (meta::DerivedFromOrSameAs<Model, BaseModel>) {
+    if constexpr (meta::DerivedFromOrSameAs<Model, models::BaseModel>) {
       addFunctions(
           JSI_EXPORT_FUNCTION(ModelHostObject<Model>, unload, "unload"));
     }
 
-    if constexpr (meta::DerivedFromOrSameAs<Model, BaseModel>) {
+    if constexpr (meta::DerivedFromOrSameAs<Model, models::BaseModel>) {
       addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
                                        promiseHostFunction<&Model::forwardJS>,
                                        "forward"));
     }
 
-    if constexpr (meta::DerivedFromOrSameAs<Model, BaseModel>) {
+    if constexpr (meta::DerivedFromOrSameAs<Model, models::BaseModel>) {
       addFunctions(JSI_EXPORT_FUNCTION(
           ModelHostObject<Model>, promiseHostFunction<&Model::getInputShape>,
           "getInputShape"));
@@ -77,12 +80,26 @@ public:
                                        promiseHostFunction<&Model::tokenToId>,
                                        "tokenToId"));
     }
-    if constexpr (meta::SameAs<Model, OCR>) {
+
+    if constexpr (meta::SameAs<Model, models::llm::LLM>) {
+      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
+                                       promiseHostFunction<&Model::generate>,
+                                       "generate"));
+
+      addFunctions(JSI_EXPORT_FUNCTION(
+          ModelHostObject<Model>, synchronousHostFunction<&Model::interrupt>,
+          "interrupt"));
+
       addFunctions(
           JSI_EXPORT_FUNCTION(ModelHostObject<Model>, unload, "unload"));
     }
 
-    if constexpr (meta::SameAs<Model, VerticalOCR>) {
+    if constexpr (meta::SameAs<Model, models::ocr::OCR>) {
+      addFunctions(
+          JSI_EXPORT_FUNCTION(ModelHostObject<Model>, unload, "unload"));
+    }
+
+    if constexpr (meta::SameAs<Model, models::ocr::VerticalOCR>) {
       addFunctions(
           JSI_EXPORT_FUNCTION(ModelHostObject<Model>, unload, "unload"));
     }
@@ -93,10 +110,10 @@ public:
   template <auto FnPtr> JSI_HOST_FUNCTION(synchronousHostFunction) {
     constexpr std::size_t functionArgCount = meta::getArgumentCount(FnPtr);
     if (functionArgCount != count) {
-      char errorMessage[100];
-      std::snprintf(errorMessage, sizeof(errorMessage),
-                    "Argument count mismatch, was expecting: %zu but got: %zu",
-                    functionArgCount, count);
+      std::stringstream ss;
+      ss << "Argument count mismatch, was expecting: " << functionArgCount
+         << " but got: " << count;
+      const auto errorMessage = ss.str();
       throw jsi::JSError(runtime, errorMessage);
     }
 
@@ -112,7 +129,7 @@ public:
         // For non-void functions, capture the result and convert it
         auto result =
             std::apply(std::bind_front(FnPtr, model), std::move(argsConverted));
-        return jsiconversion::getJsiValue(std::move(result), runtime);
+        return jsi_conversion::getJsiValue(std::move(result), runtime);
       }
     } catch (const std::runtime_error &e) {
       // This catch should be merged with the next one
@@ -129,6 +146,9 @@ public:
     }
   }
 
+  // A generic host function that resolves a promise with a result of a
+  // function. JSI arguments are converted to the types provided in the function
+  // signature, and the return value is converted back to JSI before resolving.
   template <auto FnPtr> JSI_HOST_FUNCTION(promiseHostFunction) {
     auto promise = Promise::createPromise(
         runtime, callInvoker,
@@ -136,11 +156,10 @@ public:
           constexpr std::size_t functionArgCount =
               meta::getArgumentCount(FnPtr);
           if (functionArgCount != count) {
-            char errorMessage[100];
-            std::snprintf(
-                errorMessage, sizeof(errorMessage),
-                "Argument count mismatch, was expecting: %zu but got: %zu",
-                functionArgCount, count);
+            std::stringstream ss;
+            ss << "Argument count mismatch, was expecting: " << functionArgCount
+               << " but got: " << count;
+            const auto errorMessage = ss.str();
             promise->reject(errorMessage);
             return;
           }
@@ -171,11 +190,11 @@ public:
                                            std::move(argsConverted));
                   // The result is copied. It should either be quickly copiable,
                   // or passed with a shared_ptr.
-                  callInvoker->invokeAsync([promise,
-                                            result](jsi::Runtime &runtime) {
-                    promise->resolve(
-                        jsiconversion::getJsiValue(std::move(result), runtime));
-                  });
+                  callInvoker->invokeAsync(
+                      [promise, result](jsi::Runtime &runtime) {
+                        promise->resolve(jsi_conversion::getJsiValue(
+                            std::move(result), runtime));
+                      });
                 }
               } catch (const std::runtime_error &e) {
                 // This catch should be merged with the next two

package/common/rnexecutorch/metaprogramming/ConstructorHelpers.h

@@ -87,7 +87,7 @@ std::tuple<Types...> fillConstructorTupleFromArgs(
     if constexpr (I == lastIndex) {
       return jsCallInvoker;
     } else {
-      return jsiconversion::getValue<Types>(args[I], runtime);
+      return jsi_conversion::getValue<Types>(args[I], runtime);
     }
   }()...);
 }
@@ -118,12 +118,14 @@ auto createConstructorArgsWithCallInvoker(
 
 } // namespace meta
 
-// A helper macro to create ConstructorTraits for a class. The variadic pack
-// ("...") should list the types of the constructor arguments.
-// A class declaration is added so that we don't need to include the class
-// definition.
+/**
+ * @brief A helper macro to create ConstructorTraits for a class. The variadic
+ * pack
+ * ("...") should list the types of the constructor arguments.
+ * @note The Class must be fully declared or forward-declared before this macro
+ * is invoked
+ */
 #define REGISTER_CONSTRUCTOR(Class, ...)                                       \
-  class Class;                                                                 \
   template <> struct meta::ConstructorTraits<Class> {                          \
     using arg_types = std::tuple<__VA_ARGS__>;                                 \
   }

package/common/rnexecutorch/metaprogramming/FunctionHelpers.h

@@ -23,7 +23,7 @@ template <typename... Types, std::size_t... I>
 std::tuple<Types...> fillTupleFromArgs(std::index_sequence<I...>,
                                        const jsi::Value *args,
                                        jsi::Runtime &runtime) {
-  return std::make_tuple(jsiconversion::getValue<Types>(args[I], runtime)...);
+  return std::make_tuple(jsi_conversion::getValue<Types>(args[I], runtime)...);
 }
 
 /**

package/common/rnexecutorch/models/BaseModel.cpp

@@ -4,7 +4,7 @@
 #include <filesystem>
 #include <stdexcept>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models {
 
 using namespace facebook;
 using namespace executorch::extension;
@@ -178,4 +178,4 @@ BaseModel::getTensorShape(const executorch::aten::Tensor &tensor) {
   return std::vector<int32_t>(sizes.begin(), sizes.end());
 }
 
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models

package/common/rnexecutorch/models/BaseModel.h

@@ -3,6 +3,7 @@
 #include <string>
 #include <vector>
 
+#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
 #include <ReactCommon/CallInvoker.h>
 #include <executorch/extension/module/module.h>
 #include <jsi/jsi.h>
@@ -10,6 +11,7 @@
 #include <rnexecutorch/host_objects/JSTensorViewOut.h>
 
 namespace rnexecutorch {
+namespace models {
 using namespace facebook;
 using executorch::runtime::EValue;
 using executorch::runtime::Result;
@@ -43,5 +45,8 @@ private:
   std::size_t memorySizeLowerBound{0};
   std::vector<int32_t> getTensorShape(const executorch::aten::Tensor &tensor);
 };
+} // namespace models
 
+REGISTER_CONSTRUCTOR(models::BaseModel, std::string,
+                     std::shared_ptr<react::CallInvoker>);
 } // namespace rnexecutorch

package/common/rnexecutorch/models/EncoderDecoderBase.cpp

@@ -1,6 +1,6 @@
 #include <rnexecutorch/models/EncoderDecoderBase.h>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models {
 
 EncoderDecoderBase::EncoderDecoderBase(
     const std::string &encoderPath, const std::string &decoderPath,
@@ -18,4 +18,4 @@ void EncoderDecoderBase::unload() noexcept {
   decoder_.reset(nullptr);
 }
 
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models

package/common/rnexecutorch/models/EncoderDecoderBase.h

@@ -5,7 +5,7 @@
 #include <rnexecutorch/models/BaseModel.h>
 #include <string>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models {
 
 using namespace facebook;
 using executorch::aten::Tensor;
@@ -28,4 +28,4 @@ private:
   size_t memorySizeLowerBound;
 };
 
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models

package/common/rnexecutorch/models/classification/Classification.cpp

@@ -6,7 +6,7 @@
 #include <rnexecutorch/data_processing/Numerical.h>
 #include <rnexecutorch/models/classification/Constants.h>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::classification {
 
 Classification::Classification(const std::string &modelSource,
                                std::shared_ptr<react::CallInvoker> callInvoker)
@@ -31,7 +31,7 @@ Classification::Classification(const std::string &modelSource,
 std::unordered_map<std::string_view, float>
 Classification::generate(std::string imageSource) {
   auto inputTensor =
-      imageprocessing::readImageToTensor(imageSource, getAllInputShapes()[0])
+      image_processing::readImageToTensor(imageSource, getAllInputShapes()[0])
           .first;
   auto forwardResult = BaseModel::forward(inputTensor);
   if (!forwardResult.ok()) {
@@ -49,13 +49,13 @@ Classification::postprocess(const Tensor &tensor) {
       static_cast<const float *>(tensor.const_data_ptr()), tensor.numel());
   std::vector<float> resultVec(resultData.begin(), resultData.end());
 
-  if (resultVec.size() != IMAGENET1K_V1_LABELS.size()) {
+  if (resultVec.size() != constants::kImagenet1kV1Labels.size()) {
     char errorMessage[100];
     std::snprintf(
         errorMessage, sizeof(errorMessage),
         "Unexpected classification output size, was expecting: %zu classes "
         "but got: %zu classes",
-        IMAGENET1K_V1_LABELS.size(), resultVec.size());
+        constants::kImagenet1kV1Labels.size(), resultVec.size());
     throw std::runtime_error(errorMessage);
   }
 
@@ -63,10 +63,10 @@ Classification::postprocess(const Tensor &tensor) {
 
   std::unordered_map<std::string_view, float> probs;
   for (std::size_t cl = 0; cl < resultVec.size(); ++cl) {
-    probs[IMAGENET1K_V1_LABELS[cl]] = resultVec[cl];
+    probs[constants::kImagenet1kV1Labels[cl]] = resultVec[cl];
   }
 
   return probs;
 }
 
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::classification

package/common/rnexecutorch/models/classification/Classification.h

@@ -5,9 +5,11 @@
 #include <executorch/extension/tensor/tensor_ptr.h>
 #include <opencv2/opencv.hpp>
 
+#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
 #include <rnexecutorch/models/BaseModel.h>
 
 namespace rnexecutorch {
+namespace models::classification {
 using executorch::aten::Tensor;
 using executorch::extension::TensorPtr;
 
@@ -22,5 +24,8 @@ private:
 
   cv::Size modelImageSize{0, 0};
 };
+} // namespace models::classification
 
+REGISTER_CONSTRUCTOR(models::classification::Classification, std::string,
+                     std::shared_ptr<react::CallInvoker>);
 } // namespace rnexecutorch

package/common/rnexecutorch/models/classification/Constants.h

@@ -3,8 +3,8 @@
 #include <array>
 #include <string_view>
 
-namespace rnexecutorch {
-inline constexpr std::array<std::string_view, 1000> IMAGENET1K_V1_LABELS = {
+namespace rnexecutorch::models::classification::constants {
+inline constexpr std::array<std::string_view, 1000> kImagenet1kV1Labels = {
     "tench, Tinca tinca",
     "goldfish, Carassius auratus",
     "great white shark, white shark, man-eater, man-eating shark, Carcharodon "
@@ -1019,4 +1019,4 @@ inline constexpr std::array<std::string_view, 1000> IMAGENET1K_V1_LABELS = {
     "bolete",
     "ear, spike, capitulum",
     "toilet tissue, toilet paper, bathroom tissue"};
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::classification::constants

package/common/rnexecutorch/models/embeddings/BaseEmbeddings.cpp

@@ -2,7 +2,7 @@
 
 #include <span>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::embeddings {
 
 BaseEmbeddings::BaseEmbeddings(const std::string &modelSource,
                                std::shared_ptr<react::CallInvoker> callInvoker)
@@ -24,4 +24,4 @@ BaseEmbeddings::postprocess(const Result<std::vector<EValue>> &forwardResult) {
   return createBuffer(modelOutput.data(), modelOutput.size_bytes());
 }
 
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::embeddings

package/common/rnexecutorch/models/embeddings/BaseEmbeddings.h

@@ -2,7 +2,7 @@
 
 #include <rnexecutorch/models/BaseModel.h>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::embeddings {
 
 class BaseEmbeddings : public BaseModel {
 public:
@@ -14,4 +14,4 @@ protected:
   postprocess(const Result<std::vector<EValue>> &forwardResult);
 };
 
-}; // namespace rnexecutorch
+}; // namespace rnexecutorch::models::embeddings

package/common/rnexecutorch/models/embeddings/image/ImageEmbeddings.cpp

@@ -4,7 +4,7 @@
 #include <rnexecutorch/data_processing/ImageProcessing.h>
 #include <rnexecutorch/data_processing/Numerical.h>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::embeddings {
 
 ImageEmbeddings::ImageEmbeddings(
     const std::string &modelSource,
@@ -30,7 +30,7 @@ ImageEmbeddings::ImageEmbeddings(
 std::shared_ptr<OwningArrayBuffer>
 ImageEmbeddings::generate(std::string imageSource) {
   auto [inputTensor, originalSize] =
-      imageprocessing::readImageToTensor(imageSource, getAllInputShapes()[0]);
+      image_processing::readImageToTensor(imageSource, getAllInputShapes()[0]);
 
   auto forwardResult = BaseModel::forward(inputTensor);
   if (!forwardResult.ok()) {
@@ -42,4 +42,4 @@ ImageEmbeddings::generate(std::string imageSource) {
   return BaseEmbeddings::postprocess(forwardResult);
 }
 
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::embeddings

package/common/rnexecutorch/models/embeddings/image/ImageEmbeddings.h

@@ -4,9 +4,11 @@
 #include <executorch/runtime/core/evalue.h>
 #include <opencv2/opencv.hpp>
 
+#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
 #include <rnexecutorch/models/embeddings/BaseEmbeddings.h>
 
 namespace rnexecutorch {
+namespace models::embeddings {
 using executorch::extension::TensorPtr;
 using executorch::runtime::EValue;
 
@@ -19,5 +21,8 @@ public:
 private:
   cv::Size modelImageSize{0, 0};
 };
+} // namespace models::embeddings
 
+REGISTER_CONSTRUCTOR(models::embeddings::ImageEmbeddings, std::string,
+                     std::shared_ptr<react::CallInvoker>);
 } // namespace rnexecutorch

package/common/rnexecutorch/models/embeddings/text/TextEmbeddings.cpp

@@ -2,7 +2,7 @@
 #include <executorch/extension/tensor/tensor_ptr_maker.h>
 #include <rnexecutorch/data_processing/Numerical.h>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::embeddings {
 
 using namespace executorch::extension;
 
@@ -58,4 +58,4 @@ TextEmbeddings::generate(const std::string input) {
   return BaseEmbeddings::postprocess(forwardResult);
 }
 
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::embeddings

package/common/rnexecutorch/models/embeddings/text/TextEmbeddings.h

@@ -1,9 +1,11 @@
 #pragma once
 
+#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
 #include <rnexecutorch/TokenizerModule.h>
 #include <rnexecutorch/models/embeddings/BaseEmbeddings.h>
 
 namespace rnexecutorch {
+namespace models::embeddings {
 
 struct TokenIdsWithAttentionMask {
   std::vector<int64_t> inputIds;
@@ -22,5 +24,8 @@ private:
   TokenIdsWithAttentionMask preprocess(const std::string &input);
   std::unique_ptr<TokenizerModule> tokenizer;
 };
+} // namespace models::embeddings
 
-}; // namespace rnexecutorch
+REGISTER_CONSTRUCTOR(models::embeddings::TextEmbeddings, std::string,
+                     std::string, std::shared_ptr<react::CallInvoker>);
+} // namespace rnexecutorch

package/common/rnexecutorch/models/image_segmentation/Constants.h

@@ -3,11 +3,11 @@
 #include <array>
 #include <string_view>
 
-namespace rnexecutorch {
-inline constexpr std::array<std::string_view, 21> DEEPLABV3_RESNET50_LABELS = {
+namespace rnexecutorch::models::image_segmentation::constants {
+inline constexpr std::array<std::string_view, 21> kDeeplabV3Resnet50Labels = {
     "BACKGROUND", "AEROPLANE",   "BICYCLE", "BIRD",  "BOAT",
     "BOTTLE",     "BUS",         "CAR",     "CAT",   "CHAIR",
     "COW",        "DININGTABLE", "DOG",     "HORSE", "MOTORBIKE",
     "PERSON",     "POTTEDPLANT", "SHEEP",   "SOFA",  "TRAIN",
     "TVMONITOR"};
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::image_segmentation::constants

package/common/rnexecutorch/models/image_segmentation/ImageSegmentation.cpp

@@ -9,7 +9,7 @@
 #include <rnexecutorch/host_objects/JsiConversions.h>
 #include <rnexecutorch/models/image_segmentation/Constants.h>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::image_segmentation {
 
 ImageSegmentation::ImageSegmentation(
     const std::string &modelSource,
@@ -37,7 +37,7 @@ std::shared_ptr<jsi::Object> ImageSegmentation::generate(
     std::string imageSource,
     std::set<std::string, std::less<>> classesOfInterest, bool resize) {
   auto [inputTensor, originalSize] =
-      imageprocessing::readImageToTensor(imageSource, getAllInputShapes()[0]);
+      image_processing::readImageToTensor(imageSource, getAllInputShapes()[0]);
 
   auto forwardResult = BaseModel::forward(inputTensor);
   if (!forwardResult.ok()) {
@@ -101,8 +101,9 @@ std::shared_ptr<jsi::Object> ImageSegmentation::postprocess(
   auto buffersToReturn = std::make_shared<std::unordered_map<
       std::string_view, std::shared_ptr<OwningArrayBuffer>>>();
   for (std::size_t cl = 0; cl < numClasses; ++cl) {
-    if (classesOfInterest.contains(DEEPLABV3_RESNET50_LABELS[cl])) {
-      (*buffersToReturn)[DEEPLABV3_RESNET50_LABELS[cl]] = resultClasses[cl];
+    if (classesOfInterest.contains(constants::kDeeplabV3Resnet50Labels[cl])) {
+      (*buffersToReturn)[constants::kDeeplabV3Resnet50Labels[cl]] =
+          resultClasses[cl];
     }
   }
 
@@ -170,4 +171,4 @@ std::shared_ptr<jsi::Object> ImageSegmentation::populateDictionary(
   return dictPtr;
 }
 
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::image_segmentation

package/common/rnexecutorch/models/image_segmentation/ImageSegmentation.h

@@ -7,11 +7,13 @@
 #include <jsi/jsi.h>
 #include <opencv2/opencv.hpp>
 
+#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
 #include <rnexecutorch/jsi/OwningArrayBuffer.h>
 #include <rnexecutorch/models/BaseModel.h>
 #include <rnexecutorch/models/image_segmentation/Constants.h>
 
 namespace rnexecutorch {
+namespace models::image_segmentation {
 using namespace facebook;
 
 using executorch::aten::Tensor;
@@ -36,8 +38,13 @@ private:
                                          std::shared_ptr<OwningArrayBuffer>>>
           classesToOutput);
 
-  static constexpr std::size_t numClasses{DEEPLABV3_RESNET50_LABELS.size()};
+  static constexpr std::size_t numClasses{
+      constants::kDeeplabV3Resnet50Labels.size()};
   cv::Size modelImageSize;
   std::size_t numModelPixels;
 };
+} // namespace models::image_segmentation
+
+REGISTER_CONSTRUCTOR(models::image_segmentation::ImageSegmentation, std::string,
+                     std::shared_ptr<react::CallInvoker>);
 } // namespace rnexecutorch

package/common/rnexecutorch/models/llm/LLM.cpp

@@ -0,0 +1,58 @@
+#include "LLM.h"
+
+#include <executorch/extension/tensor/tensor.h>
+#include <filesystem>
+
+namespace rnexecutorch::models::llm {
+using namespace facebook;
+using executorch::extension::TensorPtr;
+using executorch::runtime::Error;
+
+LLM::LLM(const std::string &modelSource, const std::string &tokenizerSource,
+         std::shared_ptr<react::CallInvoker> callInvoker)
+    : runner(std::make_unique<example::Runner>(modelSource, tokenizerSource)),
+      callInvoker(callInvoker) {
+
+  auto loadResult = runner->load();
+  if (loadResult != Error::Ok) {
+    throw std::runtime_error("Failed to load LLM runner, error code: " +
+                             std::to_string(static_cast<int>(loadResult)));
+  }
+  memorySizeLowerBound =
+      std::filesystem::file_size(std::filesystem::path(modelSource)) +
+      std::filesystem::file_size(std::filesystem::path(tokenizerSource));
+}
+
+void LLM::generate(std::string input, std::shared_ptr<jsi::Function> callback) {
+  if (!runner || !runner->is_loaded()) {
+    throw std::runtime_error("Runner is not loaded");
+  }
+
+  // Create a native callback that will invoke the JS callback on the JS thread
+  auto nativeCallback = [this, callback](const std::string &token) {
+    callInvoker->invokeAsync([callback, token](jsi::Runtime &runtime) {
+      callback->call(runtime, jsi::String::createFromUtf8(runtime, token));
+    });
+  };
+
+  auto error = runner->generate(input, nativeCallback, {}, false);
+  if (error != executorch::runtime::Error::Ok) {
+    throw std::runtime_error("Failed to generate text, error code: " +
+                             std::to_string(static_cast<int>(error)));
+  }
+}
+
+void LLM::interrupt() {
+  if (!runner || !runner->is_loaded()) {
+    throw std::runtime_error("Can't interrupt a model that's not loaded!");
+  }
+  runner->stop();
+}
+
+std::size_t LLM::getMemoryLowerBound() const noexcept {
+  return memorySizeLowerBound;
+}
+
+void LLM::unload() noexcept { runner.reset(nullptr); }
+
+} // namespace rnexecutorch::models::llm

package/common/rnexecutorch/models/llm/LLM.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
+#include <ReactCommon/CallInvoker.h>
+#include <jsi/jsi.h>
+#include <runner/runner.h>
+
+namespace rnexecutorch {
+namespace models::llm {
+using namespace facebook;
+
+class LLM {
+public:
+  explicit LLM(const std::string &modelSource,
+               const std::string &tokenizerSource,
+               std::shared_ptr<react::CallInvoker> callInvoker);
+
+  void generate(std::string input, std::shared_ptr<jsi::Function> callback);
+  void interrupt();
+  void unload() noexcept;
+  std::size_t getMemoryLowerBound() const noexcept;
+
+private:
+  size_t memorySizeLowerBound;
+  std::unique_ptr<example::Runner> runner;
+  std::shared_ptr<react::CallInvoker> callInvoker;
+};
+} // namespace models::llm
+
+REGISTER_CONSTRUCTOR(models::llm::LLM, std::string, std::string,
+                     std::shared_ptr<react::CallInvoker>);
+} // namespace rnexecutorch

package/common/rnexecutorch/models/object_detection/Constants.h

@@ -3,10 +3,10 @@
 #include <string>
 #include <unordered_map>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::object_detection::constants {
 inline constexpr float IOU_THRESHOLD = 0.55;
 
-inline const std::unordered_map<int, std::string> COCO_LABELS_MAP = {
+inline const std::unordered_map<int, std::string> kCocoLablesMap = {
     {1, "PERSON"},         {2, "BICYCLE"},       {3, "CAR"},
     {4, "MOTORCYCLE"},     {5, "AIRPLANE"},      {6, "BUS"},
     {7, "TRAIN"},          {8, "TRUCK"},         {9, "BOAT"},
@@ -38,4 +38,4 @@ inline const std::unordered_map<int, std::string> COCO_LABELS_MAP = {
     {85, "CLOCK"},         {86, "VASE"},         {87, "SCISSORS"},
     {88, "TEDDY_BEAR"},    {89, "HAIR_DRIER"},   {90, "TOOTHBRUSH"},
     {91, "HAIR_BRUSH"}};
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::object_detection::constants