react-native-executorch 0.5.1 → 0.5.3

package/android/CMakeLists.txt

@@ -14,4 +14,28 @@ set(COMMON_CPP_DIR "${CMAKE_SOURCE_DIR}/../common")
 set(LIBS_DIR "${CMAKE_SOURCE_DIR}/../third-party/android/libs")
 set(INCLUDE_DIR "${CMAKE_SOURCE_DIR}/../third-party/include")
 
+# FIXME: Below u can see miserable attempts of trying to link tokenizers-cpp 
+# directly into react-native-executorch instead of it being linked against ExecuTorch
+# and then transitively to our library. Please go back to this when we bump ET runtime to the next version.  
+# The problem with directly linking tokenizers-cpp using a submodule is that we get unresolved symbols for 
+# some android logging libraries, which are referenced by sentencepiece.
+
+# set(TOKENIZERS_CPP_DIR "${CMAKE_SOURCE_DIR}/../../../third-party/tokenizers-cpp")
+# add_subdirectory("${TOKENIZERS_CPP_DIR}" tokenizers-cpp)
+
+# # Link Android log library to sentencepiece targets
+# if(TARGET sentencepiece-static)
+#   target_link_libraries(sentencepiece-static INTERFACE log)
+# endif()
+# if(TARGET sentencepiece_train-static)
+#   target_link_libraries(sentencepiece_train-static INTERFACE log)
+# endif()
+
+# # Link log library to sentencepiece executables
+# foreach(exe spm_encode spm_decode spm_normalize spm_train spm_export_vocab)
+#   if(TARGET ${exe})
+#     target_link_libraries(${exe} log)
+#   endif()
+# endforeach()
+
 add_subdirectory("${ANDROID_CPP_DIR}")

package/android/build.gradle

@@ -168,5 +168,6 @@ dependencies {
   implementation 'com.facebook.fbjni:fbjni:0.6.0'
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
   implementation files('libs/classes.jar')
+  implementation 'org.opencv:opencv:4.10.0'
   implementation("com.squareup.okhttp3:okhttp:4.9.2")
 }

package/android/src/main/cpp/CMakeLists.txt

@@ -33,6 +33,7 @@ set(RN_VERSION_LINK_LIBRARIES
 )
 
 # Dependencies:
+
 # ------- Executorch -------
 
 add_library(executorch SHARED IMPORTED)
@@ -40,6 +41,29 @@ add_library(executorch SHARED IMPORTED)
 set_target_properties(executorch PROPERTIES
                       IMPORTED_LOCATION "${LIBS_DIR}/executorch/${ANDROID_ABI}/libexecutorch.so")
 
+                      
+if(ANDROID_ABI STREQUAL "arm64-v8a")
+  target_compile_definitions(react-native-executorch PRIVATE ARCH_ARM64)
+
+  # ------- pthreadpool -------
+  add_library(pthreadpool SHARED IMPORTED)
+  
+  set_target_properties(pthreadpool PROPERTIES
+                        IMPORTED_LOCATION "${LIBS_DIR}/pthreadpool/${ANDROID_ABI}/libpthreadpool.so"
+                        INTERFACE_INCLUDE_DIRECTORIES "${LIBS_DIR}/../../include/pthreadpool/")
+  
+  # ------- cpuinfo -------
+  add_library(cpuinfo SHARED IMPORTED)
+  
+  set_target_properties(cpuinfo PROPERTIES
+                        IMPORTED_LOCATION "${LIBS_DIR}/cpuinfo/${ANDROID_ABI}/libcpuinfo.so"
+                        INTERFACE_INCLUDE_DIRECTORIES "${LIBS_DIR}/../../include/cpuinfo/")
+  set(EXECUTORCH_LIBS
+    "pthreadpool"
+    "cpuinfo"
+  )
+endif()
+
 # ------- OpenCV -------
 
 set(OPENCV_LIBS 
@@ -70,4 +94,5 @@ target_link_libraries(
   ${OPENCV_LIBS}
   ${OPENCV_THIRD_PARTY_LIBS}
   executorch
+  ${EXECUTORCH_LIBS}
 )

package/android/src/main/java/com/swmansion/rnexecutorch/RnExecutorchPackage.kt

@@ -14,9 +14,7 @@ class RnExecutorchPackage : TurboReactPackage() {
     name: String,
     reactContext: ReactApplicationContext,
   ): NativeModule? =
-    if (name == LLM.NAME) {
-      LLM(reactContext)
-    } else if (name == ETInstaller.NAME) {
+    if (name == ETInstaller.NAME) {
       ETInstaller(reactContext)
     } else {
       null
@@ -25,16 +23,6 @@ class RnExecutorchPackage : TurboReactPackage() {
   override fun getReactModuleInfoProvider(): ReactModuleInfoProvider =
     ReactModuleInfoProvider {
       val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
-      moduleInfos[LLM.NAME] =
-        ReactModuleInfo(
-          LLM.NAME,
-          LLM.NAME,
-          false, // canOverrideExistingModule
-          false, // needsEagerInit
-          true, // hasConstants
-          false, // isCxxModule
-          true,
-        )
       moduleInfos[ETInstaller.NAME] =
         ReactModuleInfo(
           ETInstaller.NAME,

package/common/rnexecutorch/RnExecutorchInstaller.cpp

@@ -6,12 +6,19 @@
 #include <rnexecutorch/models/embeddings/image/ImageEmbeddings.h>
 #include <rnexecutorch/models/embeddings/text/TextEmbeddings.h>
 #include <rnexecutorch/models/image_segmentation/ImageSegmentation.h>
+#include <rnexecutorch/models/llm/LLM.h>
 #include <rnexecutorch/models/object_detection/ObjectDetection.h>
 #include <rnexecutorch/models/ocr/OCR.h>
 #include <rnexecutorch/models/speech_to_text/SpeechToText.h>
 #include <rnexecutorch/models/style_transfer/StyleTransfer.h>
 #include <rnexecutorch/models/vertical_ocr/VerticalOCR.h>
 
+#if defined(__ANDROID__) && defined(__aarch64__)
+#include <executorch/extension/threadpool/cpuinfo_utils.h>
+#include <executorch/extension/threadpool/threadpool.h>
+#include <rnexecutorch/Log.h>
+#endif
+
 namespace rnexecutorch {
 
 // This function fetches data from a url address. It is implemented in
@@ -26,28 +33,30 @@ void RnExecutorchInstaller::injectJSIBindings(
 
   jsiRuntime->global().setProperty(
       *jsiRuntime, "loadStyleTransfer",
-      RnExecutorchInstaller::loadModel<StyleTransfer>(jsiRuntime, jsCallInvoker,
-                                                      "loadStyleTransfer"));
+      RnExecutorchInstaller::loadModel<models::style_transfer::StyleTransfer>(
+          jsiRuntime, jsCallInvoker, "loadStyleTransfer"));
 
   jsiRuntime->global().setProperty(
       *jsiRuntime, "loadImageSegmentation",
-      RnExecutorchInstaller::loadModel<ImageSegmentation>(
+      RnExecutorchInstaller::loadModel<
+          models::image_segmentation::ImageSegmentation>(
           jsiRuntime, jsCallInvoker, "loadImageSegmentation"));
 
   jsiRuntime->global().setProperty(
       *jsiRuntime, "loadClassification",
-      RnExecutorchInstaller::loadModel<Classification>(
+      RnExecutorchInstaller::loadModel<models::classification::Classification>(
           jsiRuntime, jsCallInvoker, "loadClassification"));
 
   jsiRuntime->global().setProperty(
       *jsiRuntime, "loadObjectDetection",
-      RnExecutorchInstaller::loadModel<ObjectDetection>(
-          jsiRuntime, jsCallInvoker, "loadObjectDetection"));
+      RnExecutorchInstaller::loadModel<
+          models::object_detection::ObjectDetection>(jsiRuntime, jsCallInvoker,
+                                                     "loadObjectDetection"));
 
   jsiRuntime->global().setProperty(
       *jsiRuntime, "loadExecutorchModule",
-      RnExecutorchInstaller::loadModel<BaseModel>(jsiRuntime, jsCallInvoker,
-                                                  "loadExecutorchModule"));
+      RnExecutorchInstaller::loadModel<models::BaseModel>(
+          jsiRuntime, jsCallInvoker, "loadExecutorchModule"));
 
   jsiRuntime->global().setProperty(
       *jsiRuntime, "loadTokenizerModule",
@@ -56,23 +65,48 @@ void RnExecutorchInstaller::injectJSIBindings(
 
   jsiRuntime->global().setProperty(
       *jsiRuntime, "loadImageEmbeddings",
-      RnExecutorchInstaller::loadModel<ImageEmbeddings>(
+      RnExecutorchInstaller::loadModel<models::embeddings::ImageEmbeddings>(
           jsiRuntime, jsCallInvoker, "loadImageEmbeddings"));
+
   jsiRuntime->global().setProperty(
       *jsiRuntime, "loadTextEmbeddings",
-      RnExecutorchInstaller::loadModel<TextEmbeddings>(
+      RnExecutorchInstaller::loadModel<models::embeddings::TextEmbeddings>(
           jsiRuntime, jsCallInvoker, "loadTextEmbeddings"));
+
   jsiRuntime->global().setProperty(
-      *jsiRuntime, "loadSpeechToText",
-      RnExecutorchInstaller::loadModel<SpeechToText>(jsiRuntime, jsCallInvoker,
-                                                     "loadSpeechToText"));
+      *jsiRuntime, "loadLLM",
+      RnExecutorchInstaller::loadModel<models::llm::LLM>(
+          jsiRuntime, jsCallInvoker, "loadLLM"));
 
-  jsiRuntime->global().setProperty(*jsiRuntime, "loadOCR",
-                                   RnExecutorchInstaller::loadModel<OCR>(
-                                       jsiRuntime, jsCallInvoker, "loadOCR"));
+  jsiRuntime->global().setProperty(
+      *jsiRuntime, "loadOCR",
+      RnExecutorchInstaller::loadModel<models::ocr::OCR>(
+          jsiRuntime, jsCallInvoker, "loadOCR"));
   jsiRuntime->global().setProperty(
       *jsiRuntime, "loadVerticalOCR",
-      RnExecutorchInstaller::loadModel<VerticalOCR>(jsiRuntime, jsCallInvoker,
-                                                    "loadVerticalOCR"));
+      RnExecutorchInstaller::loadModel<models::ocr::VerticalOCR>(
+          jsiRuntime, jsCallInvoker, "loadVerticalOCR"));
+
+  jsiRuntime->global().setProperty(
+      *jsiRuntime, "loadSpeechToText",
+      RnExecutorchInstaller::loadModel<models::speech_to_text::SpeechToText>(
+          jsiRuntime, jsCallInvoker, "loadSpeechToText"));
+
+#if defined(__ANDROID__) && defined(__aarch64__)
+  auto num_of_perf_cores =
+      ::executorch::extension::cpuinfo::get_num_performant_cores();
+  log(LOG_LEVEL::Info, "Detected ", num_of_perf_cores, " performant cores");
+  // setting num_of_cores to floor(num_of_perf_cores / 2) + 1) because depending
+  // on cpu arch as when possible we want to leave at least 2 performant cores
+  // for other tasks (setting more actually results in drop of performance). For
+  // older devices (i.e. samsung s22) resolves to 3 cores, and for newer ones
+  // (like OnePlus 12) resolves to 4, which when benchamrked gives highest
+  // throughput.
+  auto num_of_cores = static_cast<uint32_t>(num_of_perf_cores / 2) + 1;
+  ::executorch::extension::threadpool::get_threadpool()
+      ->_unsafe_reset_threadpool(num_of_cores);
+  log(LOG_LEVEL::Info, "Configuring xnnpack for ", num_of_cores, " threads");
+#endif
 }
+
 } // namespace rnexecutorch

package/common/rnexecutorch/RnExecutorchInstaller.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <memory>
-#include <rnexecutorch/models/speech_to_text/SpeechToText.h>
 #include <string>
 
 #include <ReactCommon/CallInvoker.h>
@@ -17,30 +16,6 @@ namespace rnexecutorch {
 
 using FetchUrlFunc_t = std::function<std::vector<std::byte>(std::string)>;
 extern FetchUrlFunc_t fetchUrlFunc;
-
-REGISTER_CONSTRUCTOR(StyleTransfer, std::string,
-                     std::shared_ptr<react::CallInvoker>);
-REGISTER_CONSTRUCTOR(ImageSegmentation, std::string,
-                     std::shared_ptr<react::CallInvoker>);
-REGISTER_CONSTRUCTOR(Classification, std::string,
-                     std::shared_ptr<react::CallInvoker>);
-REGISTER_CONSTRUCTOR(ObjectDetection, std::string,
-                     std::shared_ptr<react::CallInvoker>);
-REGISTER_CONSTRUCTOR(BaseModel, std::string,
-                     std::shared_ptr<react::CallInvoker>);
-REGISTER_CONSTRUCTOR(TokenizerModule, std::string,
-                     std::shared_ptr<react::CallInvoker>);
-REGISTER_CONSTRUCTOR(ImageEmbeddings, std::string,
-                     std::shared_ptr<react::CallInvoker>);
-REGISTER_CONSTRUCTOR(TextEmbeddings, std::string, std::string,
-                     std::shared_ptr<react::CallInvoker>);
-REGISTER_CONSTRUCTOR(SpeechToText, std::string, std::string, std::string,
-                     std::shared_ptr<react::CallInvoker>);
-REGISTER_CONSTRUCTOR(OCR, std::string, std::string, std::string, std::string,
-                     std::string, std::shared_ptr<react::CallInvoker>);
-REGISTER_CONSTRUCTOR(VerticalOCR, std::string, std::string, std::string,
-                     std::string, bool, std::shared_ptr<react::CallInvoker>);
-
 using namespace facebook;
 
 class RnExecutorchInstaller {

package/common/rnexecutorch/TokenizerModule.cpp

@@ -10,7 +10,7 @@ TokenizerModule::TokenizerModule(
     std::string source, std::shared_ptr<react::CallInvoker> callInvoker)
     : memorySizeLowerBound(std::filesystem::file_size(source)),
       tokenizer(tokenizers::Tokenizer::FromBlobJSON(
-          fileutils::loadBytesFromFile(source))) {}
+          file_utils::loadBytesFromFile(source))) {}
 
 void TokenizerModule::ensureTokenizerLoaded(
     const std::string &methodName) const {

package/common/rnexecutorch/TokenizerModule.h

@@ -1,9 +1,9 @@
 #pragma once
 
+#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
 #include <ReactCommon/CallInvoker.h>
 #include <string>
 #include <tokenizers-cpp/tokenizers_cpp.h>
-
 namespace rnexecutorch {
 using namespace facebook;
 
@@ -23,4 +23,7 @@ private:
   std::unique_ptr<tokenizers::Tokenizer> tokenizer;
   const std::size_t memorySizeLowerBound{0};
 };
+
+REGISTER_CONSTRUCTOR(TokenizerModule, std::string,
+                     std::shared_ptr<react::CallInvoker>);
 } // namespace rnexecutorch

package/common/rnexecutorch/data_processing/FileUtils.h

@@ -5,7 +5,7 @@
 #include <fstream>
 #include <string>
 
-namespace rnexecutorch::fileutils {
+namespace rnexecutorch::file_utils {
 
 inline std::string getTimeID() {
   return std::to_string(std::chrono::duration_cast<std::chrono::milliseconds>(
@@ -27,4 +27,4 @@ inline std::string loadBytesFromFile(const std::string &path) {
   return data;
 };
 
-} // namespace rnexecutorch::fileutils
+} // namespace rnexecutorch::file_utils

package/common/rnexecutorch/data_processing/ImageProcessing.cpp

@@ -14,7 +14,7 @@ namespace rnexecutorch {
 // to this variable. It's done to not handle SSL intricacies manually, as it is
 // done automagically in ObjC++/Kotlin.
 extern FetchUrlFunc_t fetchUrlFunc;
-namespace imageprocessing {
+namespace image_processing {
 std::vector<float> colorMatToVector(const cv::Mat &mat) {
   return colorMatToVector(mat, cv::Scalar(0.0, 0.0, 0.0),
                           cv::Scalar(1.0, 1.0, 1.0));
@@ -62,7 +62,7 @@ cv::Mat bufferToColorMat(const std::span<const float> &buffer,
 }
 
 std::string saveToTempFile(const cv::Mat &image) {
-  std::string filename = "rn_executorch_" + fileutils::getTimeID() + ".png";
+  std::string filename = "rn_executorch_" + file_utils::getTimeID() + ".png";
 
   std::filesystem::path tempDir = std::filesystem::temp_directory_path();
   std::filesystem::path filePath = tempDir / filename;
@@ -212,7 +212,7 @@ std::pair<TensorPtr, cv::Size>
 readImageToTensor(const std::string &path,
                   const std::vector<int32_t> &tensorDims,
                   bool maintainAspectRatio) {
-  cv::Mat input = imageprocessing::readImage(path);
+  cv::Mat input = image_processing::readImage(path);
   cv::Size imageSize = input.size();
 
   if (tensorDims.size() < 2) {
@@ -234,7 +234,7 @@ readImageToTensor(const std::string &path,
 
   cv::cvtColor(input, input, cv::COLOR_BGR2RGB);
 
-  return {imageprocessing::getTensorFromMatrix(tensorDims, input), imageSize};
+  return {image_processing::getTensorFromMatrix(tensorDims, input), imageSize};
 }
-} // namespace imageprocessing
+} // namespace image_processing
 } // namespace rnexecutorch

package/common/rnexecutorch/data_processing/ImageProcessing.h

@@ -8,7 +8,7 @@
 #include <string>
 #include <vector>
 
-namespace rnexecutorch::imageprocessing {
+namespace rnexecutorch::image_processing {
 using executorch::aten::Tensor;
 using executorch::extension::TensorPtr;
 
@@ -52,4 +52,4 @@ std::pair<TensorPtr, cv::Size>
 readImageToTensor(const std::string &path,
                   const std::vector<int32_t> &tensorDims,
                   bool maintainAspectRatio = false);
-} // namespace rnexecutorch::imageprocessing
+} // namespace rnexecutorch::image_processing

package/common/rnexecutorch/data_processing/Numerical.cpp

@@ -2,8 +2,11 @@
 
 #include <algorithm>
 #include <cmath>
+#include <limits>
 #include <numeric>
 #include <span>
+#include <sstream>
+#include <string>
 
 namespace rnexecutorch::numerical {
 void softmax(std::vector<float> &v) {
@@ -50,6 +53,16 @@ void normalize(std::vector<float> &v) {
 
 std::vector<float> meanPooling(std::span<const float> modelOutput,
                                std::span<const int64_t> attnMask) {
+  if (attnMask.empty() || modelOutput.size() % attnMask.size() != 0) {
+    std::stringstream ss;
+    ss << "Invalid dimensions for mean pooling, expected model output size to "
+          "be divisible "
+       << "by the size of attention mask but got size: " << modelOutput.size()
+       << " for model output and size: " << attnMask.size()
+       << " for attention mask";
+    throw std::invalid_argument(ss.str());
+  }
+
   auto attnMaskLength = attnMask.size();
   auto embeddingDim = modelOutput.size() / attnMaskLength;
 

package/common/rnexecutorch/host_objects/JsiConversions.h

@@ -15,10 +15,10 @@
 
 #include <rnexecutorch/metaprogramming/TypeConcepts.h>
 #include <rnexecutorch/models/object_detection/Constants.h>
-#include <rnexecutorch/models/object_detection/Utils.h>
+#include <rnexecutorch/models/object_detection/Types.h>
 #include <rnexecutorch/models/ocr/Types.h>
 
-namespace rnexecutorch::jsiconversion {
+namespace rnexecutorch::jsi_conversion {
 
 using namespace facebook;
 
@@ -29,8 +29,6 @@ template <typename T> T getValue(const jsi::Value &val, jsi::Runtime &runtime);
 template <typename T>
   requires meta::IsNumeric<T>
 inline T getValue(const jsi::Value &val, jsi::Runtime &runtime) {
-  static_assert(std::is_integral<T>::value || std::is_floating_point<T>::value,
-                "Only integral and floating-point types are supported");
   return static_cast<T>(val.asNumber());
 }
 
@@ -46,18 +44,11 @@ inline std::string getValue<std::string>(const jsi::Value &val,
 }
 
 template <>
-inline std::vector<int32_t>
-getValue<std::vector<int32_t>>(const jsi::Value &val, jsi::Runtime &runtime) {
-  jsi::Array array = val.asObject(runtime).asArray(runtime);
-  size_t length = array.size(runtime);
-  std::vector<int32_t> result;
-  result.reserve(length);
-
-  for (size_t i = 0; i < length; ++i) {
-    jsi::Value element = array.getValueAtIndex(runtime, i);
-    result.push_back(getValue<int32_t>(element, runtime));
-  }
-  return result;
+inline std::shared_ptr<jsi::Function>
+getValue<std::shared_ptr<jsi::Function>>(const jsi::Value &val,
+                                         jsi::Runtime &runtime) {
+  return std::make_shared<jsi::Function>(
+      val.asObject(runtime).asFunction(runtime));
 }
 
 template <>
@@ -75,8 +66,8 @@ inline JSTensorViewIn getValue<JSTensorViewIn>(const jsi::Value &val,
   tensorView.sizes.reserve(numShapeDims);
 
   for (size_t i = 0; i < numShapeDims; ++i) {
-    int dim = getValue<int>(shapeArray.getValueAtIndex(runtime, i), runtime);
-    tensorView.sizes.push_back(static_cast<int32_t>(dim));
+    int32_t dim = getValue<int32_t>(shapeArray.getValueAtIndex(runtime, i), runtime);
+    tensorView.sizes.push_back(dim);
   }
 
   // On JS side, TensorPtr objects hold a 'data' property which should be either
@@ -115,38 +106,6 @@ inline JSTensorViewIn getValue<JSTensorViewIn>(const jsi::Value &val,
   return tensorView;
 }
 
-template <>
-inline std::vector<JSTensorViewIn>
-getValue<std::vector<JSTensorViewIn>>(const jsi::Value &val,
-                                      jsi::Runtime &runtime) {
-  jsi::Array array = val.asObject(runtime).asArray(runtime);
-  size_t length = array.size(runtime);
-  std::vector<JSTensorViewIn> result;
-  result.reserve(length);
-
-  for (size_t i = 0; i < length; ++i) {
-    jsi::Value element = array.getValueAtIndex(runtime, i);
-    result.push_back(getValue<JSTensorViewIn>(element, runtime));
-  }
-  return result;
-}
-
-template <>
-inline std::vector<std::string>
-getValue<std::vector<std::string>>(const jsi::Value &val,
-                                   jsi::Runtime &runtime) {
-  jsi::Array array = val.asObject(runtime).asArray(runtime);
-  size_t length = array.size(runtime);
-  std::vector<std::string> result;
-  result.reserve(length);
-
-  for (size_t i = 0; i < length; ++i) {
-    jsi::Value element = array.getValueAtIndex(runtime, i);
-    result.push_back(getValue<std::string>(element, runtime));
-  }
-  return result;
-}
-
 // C++ set from JS array. Set with heterogenerous look-up (adding std::less<>
 // enables querying with std::string_view).
 template <>
@@ -214,7 +173,26 @@ inline std::vector<T> getArrayAsVector(const jsi::Value &val,
   return result;
 }
 
+
 // Template specializations for std::vector<T> types
+template <>
+inline std::vector<JSTensorViewIn> getValue<std::vector<JSTensorViewIn>>(const jsi::Value &val,
+                                                       jsi::Runtime &runtime) {
+  return getArrayAsVector<JSTensorViewIn>(val, runtime);
+}
+
+template <>
+inline std::vector<std::string> getValue<std::vector<std::string>>(const jsi::Value &val,
+                                                       jsi::Runtime &runtime) {
+  return getArrayAsVector<std::string>(val, runtime);
+}
+
+template <>
+inline std::vector<int32_t> getValue<std::vector<int32_t>>(const jsi::Value &val,
+                                                       jsi::Runtime &runtime) {
+  return getArrayAsVector<int32_t>(val, runtime);
+}
+
 template <>
 inline std::vector<float> getValue<std::vector<float>>(const jsi::Value &val,
                                                        jsi::Runtime &runtime) {
@@ -299,17 +277,17 @@ inline jsi::Value getJsiValue(const std::vector<int32_t> &vec,
   for (size_t i = 0; i < vec.size(); i++) {
     array.setValueAtIndex(runtime, i, jsi::Value(static_cast<int>(vec[i])));
   }
-  return jsi::Value(runtime, array);
+  return {runtime, array};
 }
 
 inline jsi::Value getJsiValue(int val, jsi::Runtime &runtime) {
-  return jsi::Value(runtime, val);
+  return {runtime, val};
 }
 
 inline jsi::Value getJsiValue(const std::shared_ptr<OwningArrayBuffer> &buf,
                               jsi::Runtime &runtime) {
   jsi::ArrayBuffer arrayBuffer(runtime, buf);
-  return jsi::Value(runtime, arrayBuffer);
+  return {runtime, arrayBuffer};
 }
 
 inline jsi::Value
@@ -320,7 +298,7 @@ getJsiValue(const std::vector<std::shared_ptr<OwningArrayBuffer>> &vec,
     jsi::ArrayBuffer arrayBuffer(runtime, vec[i]);
     array.setValueAtIndex(runtime, i, jsi::Value(runtime, arrayBuffer));
   }
-  return jsi::Value(runtime, array);
+  return {runtime, array};
 }
 
 inline jsi::Value getJsiValue(const std::vector<JSTensorViewOut> &vec,
@@ -339,7 +317,7 @@ inline jsi::Value getJsiValue(const std::vector<JSTensorViewOut> &vec,
 
     array.setValueAtIndex(runtime, i, tensorObj);
   }
-  return jsi::Value(runtime, array);
+  return {runtime, array};
 }
 
 inline jsi::Value getJsiValue(const std::string &str, jsi::Runtime &runtime) {
@@ -357,8 +335,9 @@ getJsiValue(const std::unordered_map<std::string_view, float> &map,
   return mapObj;
 }
 
-inline jsi::Value getJsiValue(const std::vector<Detection> &detections,
-                              jsi::Runtime &runtime) {
+inline jsi::Value getJsiValue(
+    const std::vector<models::object_detection::types::Detection> &detections,
+    jsi::Runtime &runtime) {
   jsi::Array array(runtime, detections.size());
   for (std::size_t i = 0; i < detections.size(); ++i) {
     jsi::Object detection(runtime);
@@ -371,16 +350,18 @@ inline jsi::Value getJsiValue(const std::vector<Detection> &detections,
     detection.setProperty(runtime, "bbox", bbox);
     detection.setProperty(
         runtime, "label",
-        jsi::String::createFromAscii(runtime,
-                                     COCO_LABELS_MAP.at(detections[i].label)));
+        jsi::String::createFromAscii(
+            runtime, models::object_detection::constants::kCocoLablesMap.at(
+                         detections[i].label)));
     detection.setProperty(runtime, "score", detections[i].score);
     array.setValueAtIndex(runtime, i, detection);
   }
   return array;
 }
 
-inline jsi::Value getJsiValue(const std::vector<OCRDetection> &detections,
-                              jsi::Runtime &runtime) {
+inline jsi::Value
+getJsiValue(const std::vector<models::ocr::types::OCRDetection> &detections,
+            jsi::Runtime &runtime) {
   auto jsiDetections = jsi::Array(runtime, detections.size());
   for (size_t i = 0; i < detections.size(); ++i) {
     const auto &detection = detections[i];
@@ -407,4 +388,4 @@ inline jsi::Value getJsiValue(const std::vector<OCRDetection> &detections,
   return jsiDetections;
 }
 
-} // namespace rnexecutorch::jsiconversion
+} // namespace rnexecutorch::jsi_conversion