@novastera-oss/llamarn 0.0.1-alpha.4

package/README.md

@@ -0,0 +1,235 @@
+# LlamaRN
+
+> ⚠️ **WORK IN PROGRESS**: This package is currently under active development. Community help and feedback are greatly appreciated, especially in the areas mentioned in What Needs Help.
+
+A React Native wrapper for llama.cpp focused on providing a simple, reliable way to run LLMs on mobile devices. This project was inspired by and builds upon the excellent work of [llama.rn](https://github.com/mybigday/llama.rn).
+
+## Goals
+
+* Provide a thin, reliable wrapper around llama.cpp for React Native
+* Maintain compatibility with llama.cpp server API where possible
+* Make it easy to run LLMs on mobile devices with automatic resource management
+* Keep the codebase simple and maintainable
+
+## Current Features
+
+* Basic model loading and inference
+* Metal support on iOS
+* OpenCL/Vulkan support on Android (in progress)
+* Automatic CPU/GPU detection
+* Chat completion with templates (including Jinja template support)
+* Embeddings generation
+* Function/tool calling support
+
+## What Needs Help
+
+We welcome contributions, especially in these areas:
+
+1. **Android GPU Testing**:
+   * Testing on a variety of Android devices with different GPUs
+   * Verifying OpenCL and Vulkan acceleration on real hardware
+   * Performance profiling and optimization for mobile GPUs
+   * Adding automated GPU detection tests
+
+2. **CI Improvements**:
+   * Adding automated Android GPU tests to CI pipeline
+   * Implementing device-specific testing strategies
+   * Adding performance benchmarks to CI
+
+3. **Tool Support**:
+   * Improving tool calling functionality for complex interactions
+   * Better JSON validation and error handling
+
+4. **Testing**:
+   * Automated testing using the example project
+   * More comprehensive unit tests
+   * Cross-device compatibility tests
+
+5. **Documentation**:
+   * Improving examples and usage guides
+   * More detailed performance considerations
+
+6. **Performance**:
+   * Optimizing resource usage on different devices
+   * Memory management improvements
+   * Startup time optimization
+
+If you're interested in helping with any of these areas, please check our Contributing Guide.
+
+## Installation
+
+```sh
+npm install @novastera-oss/llamarn
+```
+
+## Basic Usage
+
+### Simple Completion
+
+```js
+import { initLlama } from '@novastera-oss/llamarn';
+
+// Initialize the model
+const context = await initLlama({
+  model: 'path/to/model.gguf',
+  n_ctx: 2048,
+  n_batch: 512
+});
+
+// Generate a completion
+const result = await context.completion({
+  prompt: 'What is artificial intelligence?',
+  temperature: 0.7,
+  top_p: 0.95
+});
+
+console.log('Response:', result.text);
+```
+
+### Chat Completion
+
+```js
+import { initLlama } from '@novastera-oss/llamarn';
+
+// Initialize the model
+const context = await initLlama({
+  model: 'path/to/model.gguf',
+  n_ctx: 4096,
+  n_batch: 512,
+  use_jinja: true  // Enable Jinja template parsing
+});
+
+// Chat completion with messages
+const result = await context.completion({
+  messages: [
+    { role: 'system', content: 'You are a helpful assistant.' },
+    { role: 'user', content: 'Tell me about quantum computing.' }
+  ],
+  temperature: 0.7,
+  top_p: 0.95
+});
+
+console.log('Response:', result.text);
+// For OpenAI-compatible format: result.choices[0].message.content
+```
+
+### Chat with Tool Calling
+
+```js
+import { initLlama } from '@novastera-oss/llamarn';
+
+// Initialize the model with appropriate parameters for tool use
+const context = await initLlama({
+  model: 'path/to/model.gguf',
+  n_ctx: 2048,
+  n_batch: 512,
+  use_jinja: true  // Enable template handling for tool calls
+});
+
+// Create a chat with tool calling
+const response = await context.completion({
+  messages: [
+    { role: 'system', content: 'You are a helpful assistant that can access weather data.' },
+    { role: 'user', content: 'What\'s the weather like in Paris?' }
+  ],
+  tools: [
+    {
+      type: 'function',
+      function: {
+        name: 'get_weather',
+        description: 'Get the current weather in a location',
+        parameters: {
+          type: 'object',
+          properties: {
+            location: {
+              type: 'string',
+              description: 'The city and state, e.g. San Francisco, CA'
+            },
+            unit: {
+              type: 'string',
+              enum: ['celsius', 'fahrenheit'],
+              description: 'The unit of temperature to use'
+            }
+          },
+          required: ['location']
+        }
+      }
+    }
+  ],
+  tool_choice: 'auto',
+  temperature: 0.7
+});
+
+// Check if the model wants to call a tool
+if (response.choices?.[0]?.finish_reason === 'tool_calls' || response.tool_calls?.length > 0) {
+  const toolCalls = response.choices?.[0]?.message?.tool_calls || response.tool_calls;
+  
+  // Process each tool call
+  if (toolCalls && toolCalls.length > 0) {
+    console.log('Function call:', toolCalls[0].function.name);
+    console.log('Arguments:', toolCalls[0].function.arguments);
+    
+    // Here you would handle the tool call and then pass the result back in a follow-up completion
+  }
+}
+```
+
+### Generating Embeddings
+
+```js
+import { initLlama } from '@novastera-oss/llamarn';
+
+// Initialize the model in embedding mode
+const context = await initLlama({
+  model: 'path/to/embedding-model.gguf',
+  embedding: true,
+  n_ctx: 2048
+});
+
+// Generate embeddings
+const embeddingResponse = await context.embedding({
+  input: "This is a sample text to embed"
+});
+
+console.log('Embedding:', embeddingResponse.data[0].embedding);
+```
+
+## Model Path Handling
+
+The module accepts different path formats depending on the platform:
+
+### iOS
+
+* Bundle path: `models/model.gguf` (if added to Xcode project)
+* Absolute path: `/path/to/model.gguf`
+
+### Android
+
+* Asset path: `asset:/models/model.gguf`
+* File path: `file:///path/to/model.gguf`
+
+## Documentation
+
+* [Interface Documentation](INTERFACE.md) - Detailed API interfaces
+* [Example App](example/) - Working example with common use cases
+* [Contributing Guide](CONTRIBUTING.md) - How to help improve the library
+
+## About
+
+Part of [Novastera's](https://novastera.com) suite of privacy-focused solutions, this package enables on-device LLM inference with no data leaving the user's device. We're committed to helping developers build AI-powered applications that respect user privacy.
+
+## License
+
+Apache 2.0 © [Novastera](https://novastera.com)
+
+## Acknowledgments
+
+We extend our heartfelt gratitude to the following projects and communities that made this library possible:
+
+* **[mybigday/llama.rn](https://github.com/mybigday/llama.rn)** - A pioneering React Native binding for llama.cpp that demonstrated the feasibility of on-device LLM inference in mobile applications.
+
+* **[Zach-Dean-Attractions-io/react-native-pure-cpp-turbo-module-library](https://github.com/Zach-Dean-Attractions-io/react-native-pure-cpp-turbo-module-library)** - A good resource that enabled us to successfully build the Android Turbo Module when the official React Native documentation proved insufficient. This repository provided the missing pieces for proper C++ integration on Android.
+
+* **[ggml-org/llama.cpp](https://github.com/ggml-org/llama.cpp)** - The underlying C++ library that powers all llama.cpp-based projects, providing efficient LLM inference capabilities.
+
+Without these contributions to the open-source community, this project would not have been possible. We're proud to continue building upon this foundation and contributing back to the ecosystem.

package/RNLlamaCpp.podspec

@@ -0,0 +1,69 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "RNLlamaCpp"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => "13.0" }
+  s.source       = { :git => "https://github.com/novastera/llamacpp-rn.git", :tag => "#{s.version}" }
+
+  # Core React Native module files - keep iOS-specific files separate
+  s.source_files = "ios/**/*.{h,m,mm}",  # iOS-specific Obj-C++ files
+                   "ios/generated/*.{h,cpp,mm}",
+                   # Core C++ module implementation (keep as .cpp)
+                   # THIS SECTION WILL BE ADJUSTED IN THE NEXT STEP IF NEEDED BASED ON ACTUAL FILE LOCATIONS
+                   "cpp/build-info.cpp", # Assuming build-info.cpp is in cpp/
+                   "cpp/PureCppImpl.{h,cpp}", # Changed from LlamaCppRnModule to PureCppImpl, assuming this is current
+                   "cpp/LlamaCppModel.{h,cpp}",
+                   "cpp/SystemUtils.{h,cpp}", # Assuming SystemUtils is in cpp/
+                   "cpp/rn-*.{hpp,cpp}", # Assuming rn-*.hpp/cpp are in cpp/
+                   # llama.cpp common utilities - Assuming these are vendored or part of the XCFramework
+                   # If these are compiled directly, their paths need to be relative to the podspec (e.g., "cpp/llama.cpp/common/common.{h,cpp}")
+                   "cpp/llama.cpp/common/common.{h,cpp}",
+                   "cpp/llama.cpp/common/log.{h,cpp}",
+                   "cpp/llama.cpp/common/sampling.{h,cpp}",
+                   "cpp/llama.cpp/common/chat.{h,cpp}",
+                   "cpp/llama.cpp/common/ngram-cache.{h,cpp}",
+                   "cpp/llama.cpp/common/json-schema-to-grammar.{h,cpp}",
+                   "cpp/llama.cpp/common/speculative.{h,cpp}",
+                   "cpp/llama.cpp/common/*.hpp",
+                   "cpp/llama.cpp/common/minja/*.hpp"
+  
+  # Include all necessary headers for compilation
+  s.preserve_paths = "ios/include/**/*.h",
+                     "ios/libs/**/*", 
+                     "cpp/**/*"
+  
+  # Use the prebuilt framework
+  s.vendored_frameworks = "ios/libs/llama.xcframework"
+
+  # Compiler settings
+  s.pod_target_xcconfig = {
+    "HEADER_SEARCH_PATHS" => "\"$(PODS_TARGET_SRCROOT)/ios/include\" \"$(PODS_TARGET_SRCROOT)/cpp\" \"$(PODS_TARGET_SRCROOT)/ios/generated/RNLlamaCppSpec\" \"$(PODS_TARGET_SRCROOT)/ios/generated\" \"$(PODS_TARGET_SRCROOT)/cpp/llama.cpp\" \"$(PODS_TARGET_SRCROOT)/cpp/llama.cpp/include\" \"$(PODS_TARGET_SRCROOT)/cpp/llama.cpp/ggml/include\" \"$(PODS_TARGET_SRCROOT)/cpp/llama.cpp/common\" \"$(PODS_ROOT)/boost\" \"$(PODS_ROOT)/Headers/Public/React-bridging\" \"$(PODS_ROOT)/Headers/Public/React\"",
+    "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -DLLAMA_METAL -DRCT_NEW_ARCH_ENABLED=1 -DFBJSRT_EXPORTED=1",
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++17",
+    "GCC_OPTIMIZATION_LEVEL" => "3", # Maximum optimization
+    "SWIFT_OPTIMIZATION_LEVEL" => "-O",
+    "ENABLE_BITCODE" => "NO",
+    "DEFINES_MODULE" => "YES",
+    "OTHER_LDFLAGS" => "$(inherited)",
+    # These preprocessor macros ensure TurboModule registration works correctly
+    "GCC_PREPROCESSOR_DEFINITIONS" => ["$(inherited)", "RCT_NEW_ARCH_ENABLED=1", 
+                                       "__STDC_FORMAT_MACROS=1", # For format macros in C++
+                                       "LLAMA_SHARED=1"]         # For llama shared symbols
+  }
+
+  # Add user_target_xcconfig to propagate linker flags
+  s.user_target_xcconfig = {
+    "OTHER_LDFLAGS" => "$(inherited)"
+  }
+
+  # Install dependencies for Turbo Modules
+  install_modules_dependencies(s)
+end

package/android/CMakeLists.txt

@@ -0,0 +1,107 @@
+cmake_minimum_required(VERSION 3.4.1)
+project(RNLlamaCpp)
+
+set(CMAKE_VERBOSE_MAKEFILE ON)
+
+# Get the absolute path to the module root and cpp directory
+get_filename_component(MODULE_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/.." ABSOLUTE)
+get_filename_component(CPP_DIR "${MODULE_ROOT}/cpp" ABSOLUTE)
+
+# Define the path to jniLibs. This assumes CMakeLists.txt is in android/
+set(JNI_LIBS_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src/main/jniLibs)
+
+# Define the path to llama.cpp directory
+set(LLAMA_CPP_DIR "${CPP_DIR}/llama.cpp")
+
+# Make sure the llama.cpp submodule exists
+if(NOT EXISTS "${LLAMA_CPP_DIR}/CMakeLists.txt")
+    message(FATAL_ERROR "llama.cpp submodule not found at ${LLAMA_CPP_DIR}. Please run 'git submodule update --init --recursive'")
+endif()
+
+# Add the prebuilt libraries as IMPORTED (64-bit architectures only: arm64-v8a, x86_64)
+add_library(llama SHARED IMPORTED)
+set_target_properties(llama PROPERTIES IMPORTED_LOCATION
+    ${JNI_LIBS_DIR}/${ANDROID_ABI}/libllama.so)
+
+add_library(ggml-base SHARED IMPORTED)
+set_target_properties(ggml-base PROPERTIES IMPORTED_LOCATION
+    ${JNI_LIBS_DIR}/${ANDROID_ABI}/libggml-base.so)
+
+add_library(ggml SHARED IMPORTED)
+set_target_properties(ggml PROPERTIES IMPORTED_LOCATION
+    ${JNI_LIBS_DIR}/${ANDROID_ABI}/libggml.so)
+
+add_library(ggml-cpu SHARED IMPORTED)
+set_target_properties(ggml-cpu PROPERTIES IMPORTED_LOCATION
+    ${JNI_LIBS_DIR}/${ANDROID_ABI}/libggml-cpu.so)
+
+# Create a minimal common library with only essential files that don't require missing GGML symbols
+add_library(
+    common
+    STATIC
+    # Add back essential files now that we have prebuilt GGML libraries
+    ${CPP_DIR}/llama.cpp/common/build-info.cpp
+    ${CPP_DIR}/llama.cpp/common/log.cpp
+    ${CPP_DIR}/llama.cpp/common/common.cpp
+    ${CPP_DIR}/llama.cpp/common/sampling.cpp
+    ${CPP_DIR}/llama.cpp/common/chat.cpp
+    ${CPP_DIR}/llama.cpp/common/json-schema-to-grammar.cpp
+)
+
+add_library(
+    RNLlamaCpp
+    SHARED
+    ${CPP_DIR}/build-info.cpp
+    ${CPP_DIR}/PureCppImpl.cpp
+    ${CPP_DIR}/LlamaCppModel.cpp
+    ${CPP_DIR}/SystemUtils.cpp
+    ${CPP_DIR}/rn-completion.cpp
+)
+
+# Include directories
+target_include_directories(common PRIVATE
+    ${CPP_DIR}
+    ${LLAMA_CPP_DIR}/ggml/include
+    ${LLAMA_CPP_DIR}/include
+    ${LLAMA_CPP_DIR}/common
+    ${LLAMA_CPP_DIR}/common/minja  # Add this for chat-template.hpp
+    ${LLAMA_CPP_DIR}/src
+)
+
+target_include_directories(RNLlamaCpp PRIVATE
+    ${CPP_DIR}
+    ${LLAMA_CPP_DIR}/ggml/include
+    ${LLAMA_CPP_DIR}/include
+    ${LLAMA_CPP_DIR}/common
+    ${LLAMA_CPP_DIR}/common/minja  # Add this for chat-template.hpp
+    ${LLAMA_CPP_DIR}/src
+    # Add the generated headers path
+    ${MODULE_ROOT}/android/generated/jni
+    ${MODULE_ROOT}/android/generated/jni/react/renderer/components/RNLlamaCppSpec
+)
+
+# Link libraries
+target_link_libraries(
+    RNLlamaCpp
+    common
+    react_codegen_RNLlamaCppSpec  # Link against the generated TurboModule code
+    llama       # Link against the imported prebuilt core llama library (now named llama)
+    ggml-base   # Link against the imported GGML base library (contains ggml_abort, ggml_time_us, gguf_*)
+    ggml        # Link against the imported GGML library (contains ggml_backend_load_all)
+    ggml-cpu    # Link against the imported GGML CPU library
+    jsi
+    reactnative
+    fbjni
+    android
+    log
+)
+
+# Expose our headers to consuming targets (for autolinking)
+target_include_directories(RNLlamaCpp INTERFACE
+    ${CPP_DIR}
+    ${LLAMA_CPP_DIR}/ggml/include
+    ${LLAMA_CPP_DIR}/include
+    ${LLAMA_CPP_DIR}/common
+    ${LLAMA_CPP_DIR}/common/minja
+    ${LLAMA_CPP_DIR}/src
+)

package/android/build.gradle

@@ -0,0 +1,111 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['RNLlamaCpp_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["arm64-v8a", "x86_64"]  // Only 64-bit architectures
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["RNLlamaCpp_" + name]).toInteger()
+}
+
+def supportsNamespace() {
+  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
+  def major = parsed[0].toInteger()
+  def minor = parsed[1].toInteger()
+
+  // Namespace support was added in 7.3.0
+  return (major == 7 && minor >= 3) || major >= 8
+}
+
+android {
+  if (supportsNamespace()) {
+    namespace "com.novastera.llamarn"
+
+    sourceSets {
+      main {
+        manifest.srcFile "src/main/AndroidManifestNew.xml"
+      }
+    }
+  }
+
+  sourceSets {
+    main {
+      jni.srcDirs = []
+      jniLibs.srcDirs = ['src/main/jniLibs']
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
+
+  ndkVersion getExtOrDefault("ndkVersion")
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+
+
+  }
+
+
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+}
+
+react {
+ jsRootDir = file("../src/")
+ libraryName = "RNLlamaCpp"
+ codegenJavaPackageName = "com.novastera.llamarn"
+}

package/android/generated/java/com/novastera/llamarn/NativeRNLlamaCppSpec.java

@@ -0,0 +1,47 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleJavaSpec.js
+ *
+ * @nolint
+ */
+
+package com.novastera.llamarn;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.turbomodule.core.interfaces.TurboModule;
+import javax.annotation.Nonnull;
+
+public abstract class NativeRNLlamaCppSpec extends ReactContextBaseJavaModule implements TurboModule {
+  public static final String NAME = "RNLlamaCpp";
+
+  public NativeRNLlamaCppSpec(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public @Nonnull String getName() {
+    return NAME;
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  @DoNotStrip
+  public abstract double multiply(double a, double b);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void initLlama(ReadableMap params, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void loadLlamaModelInfo(String modelPath, Promise promise);
+}

package/android/generated/jni/CMakeLists.txt

@@ -0,0 +1,36 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+file(GLOB react_codegen_SRCS CONFIGURE_DEPENDS *.cpp react/renderer/components/RNLlamaCppSpec/*.cpp)
+
+add_library(
+  react_codegen_RNLlamaCppSpec
+  OBJECT
+  ${react_codegen_SRCS}
+)
+
+target_include_directories(react_codegen_RNLlamaCppSpec PUBLIC . react/renderer/components/RNLlamaCppSpec)
+
+target_link_libraries(
+  react_codegen_RNLlamaCppSpec
+  fbjni
+  jsi
+  # We need to link different libraries based on whether we are building rncore or not, that's necessary
+  # because we want to break a circular dependency between react_codegen_rncore and reactnative
+  reactnative
+)
+
+target_compile_options(
+  react_codegen_RNLlamaCppSpec
+  PRIVATE
+  -DLOG_TAG=\"ReactNative\"
+  -fexceptions
+  -frtti
+  -std=c++20
+  -Wall
+)

package/android/generated/jni/RNLlamaCppSpec-generated.cpp

@@ -0,0 +1,44 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleJniCpp.js
+ */
+
+#include "RNLlamaCppSpec.h"
+
+namespace facebook::react {
+
+static facebook::jsi::Value __hostFunction_NativeRNLlamaCppSpecJSI_multiply(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+  static jmethodID cachedMethodId = nullptr;
+  return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, NumberKind, "multiply", "(DD)D", args, count, cachedMethodId);
+}
+
+static facebook::jsi::Value __hostFunction_NativeRNLlamaCppSpecJSI_initLlama(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+  static jmethodID cachedMethodId = nullptr;
+  return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, PromiseKind, "initLlama", "(Lcom/facebook/react/bridge/ReadableMap;Lcom/facebook/react/bridge/Promise;)V", args, count, cachedMethodId);
+}
+
+static facebook::jsi::Value __hostFunction_NativeRNLlamaCppSpecJSI_loadLlamaModelInfo(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+  static jmethodID cachedMethodId = nullptr;
+  return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, PromiseKind, "loadLlamaModelInfo", "(Ljava/lang/String;Lcom/facebook/react/bridge/Promise;)V", args, count, cachedMethodId);
+}
+
+NativeRNLlamaCppSpecJSI::NativeRNLlamaCppSpecJSI(const JavaTurboModule::InitParams &params)
+  : JavaTurboModule(params) {
+  methodMap_["multiply"] = MethodMetadata {2, __hostFunction_NativeRNLlamaCppSpecJSI_multiply};
+  methodMap_["initLlama"] = MethodMetadata {1, __hostFunction_NativeRNLlamaCppSpecJSI_initLlama};
+  methodMap_["loadLlamaModelInfo"] = MethodMetadata {1, __hostFunction_NativeRNLlamaCppSpecJSI_loadLlamaModelInfo};
+}
+
+std::shared_ptr<TurboModule> RNLlamaCppSpec_ModuleProvider(const std::string &moduleName, const JavaTurboModule::InitParams &params) {
+  if (moduleName == "RNLlamaCpp") {
+    return std::make_shared<NativeRNLlamaCppSpecJSI>(params);
+  }
+  return nullptr;
+}
+
+} // namespace facebook::react

package/android/generated/jni/RNLlamaCppSpec.h

@@ -0,0 +1,31 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleJniH.js
+ */
+
+#pragma once
+
+#include <ReactCommon/JavaTurboModule.h>
+#include <ReactCommon/TurboModule.h>
+#include <jsi/jsi.h>
+
+namespace facebook::react {
+
+/**
+ * JNI C++ class for module 'NativeRNLlamaCpp'
+ */
+class JSI_EXPORT NativeRNLlamaCppSpecJSI : public JavaTurboModule {
+public:
+  NativeRNLlamaCppSpecJSI(const JavaTurboModule::InitParams &params);
+};
+
+
+JSI_EXPORT
+std::shared_ptr<TurboModule> RNLlamaCppSpec_ModuleProvider(const std::string &moduleName, const JavaTurboModule::InitParams &params);
+
+} // namespace facebook::react