@dr33m/react-native-litert-lm 0.5.0

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

@@ -0,0 +1,380 @@
+import type { HybridObject } from "react-native-nitro-modules";
+/**
+ * Backend types for LLM inference.
+ * - 'cpu': CPU inference (slowest, always available)
+ * - 'gpu': GPU acceleration (fast, recommended for most devices)
+ * - 'npu': NPU/Neural Engine (fastest on supported hardware)
+ *
+ * @remarks
+ * NPU acceleration requires compatible hardware (e.g., Qualcomm Hexagon, MediaTek APU).
+ * If NPU is unavailable, LiteRT-LM automatically falls back to GPU.
+ */
+export type Backend = "cpu" | "gpu" | "npu";
+/**
+ * Message roles for conversation.
+ */
+export type Role = "user" | "model" | "system";
+/**
+ * Definition for a function/tool that the model can request to execute.
+ */
+export interface ToolDefinition {
+    /** Name of the function/tool */
+    name: string;
+    /** Human-readable description of what the function/tool does */
+    description: string;
+    /** JSON schema defining parameter names and types (stringified) */
+    parametersJson: string;
+}
+/**
+ * A tool call requested by the model during inference.
+ */
+export interface ToolCall {
+    /** Name of the tool the model wants to call */
+    name: string;
+    /** JSON string of the arguments the model passed to the tool */
+    argumentsJson: string;
+}
+/**
+ * A tool response to send back to the model after executing a tool call.
+ */
+export interface ToolResponse {
+    /** Name of the tool that was executed */
+    name: string;
+    /** JSON string of the tool execution result */
+    responseJson: string;
+}
+/**
+ * Result from execute() containing both text and any tool calls.
+ */
+export interface ExecuteResult {
+    /** The model's text response */
+    text: string;
+    /** Tool calls requested by the model (empty array if none) */
+    toolCalls: ToolCall[];
+    /** The model's internal thinking/reasoning text (empty string if thinking is disabled) */
+    thinkingText: string;
+}
+/**
+ * The part type for a multimodal message content part.
+ */
+export type PartType = "text" | "image" | "audio";
+/**
+ * A part of a unified multimodal message payload.
+ */
+export interface MultimodalPart {
+    /** The part type: 'text', 'image', or 'audio' */
+    type: PartType;
+    /** The plain text content, if type is 'text' */
+    text?: string;
+    /**
+     * Local filesystem path to an image or audio file, if type is 'image' or 'audio'.
+     * Takes precedence over `imageBuffer`/`audioBuffer` if both are set.
+     */
+    path?: string;
+    /** Raw image binary data, if type is 'image' (zero-copy ArrayBuffer mapping) */
+    imageBuffer?: ArrayBuffer;
+    /** Raw audio binary data, if type is 'audio' (zero-copy ArrayBuffer mapping) */
+    audioBuffer?: ArrayBuffer;
+}
+/**
+ * Configuration options for loading an LLM.
+ */
+export interface LLMConfig {
+    /**
+     * System prompt to set the model's behavior.
+     * This is prepended to the conversation to guide model responses.
+     * @example "You are a helpful coding assistant."
+     */
+    systemPrompt?: string;
+    /**
+     * Primary compute backend for text generation.
+     * - 'cpu': CPU inference (safe default, always available)
+     * - 'gpu': GPU acceleration (fast, Metal on iOS, GPU delegate on Android)
+     * - 'npu': NPU/Neural Engine (fastest on supported devices)
+     *
+     * If not specified, defaults to 'cpu'.
+     * If specified backend is unavailable, falls back automatically.
+     *
+     * @remarks
+     * Vision encoder is always set to GPU (required by Gemma models).
+     * Audio encoder is always set to CPU (optimal for audio processing).
+     *
+     * @default 'cpu'
+     */
+    backend?: Backend;
+    /**
+     * Total engine KV-cache budget in tokens (prompt + history + output combined).
+     * Must be ≥ the total number of input tokens + desired output tokens.
+     * For compiled bundles, should not exceed the bundle's compiled cache_length.
+     * @default 4096
+     */
+    maxContextTokens?: number;
+    /**
+     * Maximum number of tokens the model generates per response.
+     * For compiled bundles, must not exceed the bundle's compiled decode-chunk size.
+     *
+     * @remarks
+     * **iOS only** — the Android Kotlin SDK does not currently expose per-session
+     * output token control. On Android this value is accepted but has no effect;
+     * the engine uses its own default.
+     *
+     * @default 1024
+     */
+    maxOutputTokens?: number;
+    /**
+     * Maximum number of tokens to generate.
+     * @deprecated Use `maxContextTokens` and `maxOutputTokens` instead.
+     * When set alone (without the new fields), maps to both for backward compatibility.
+     * @default 1024
+     */
+    maxTokens?: number;
+    /**
+     * Sampling temperature (0.0 = deterministic, 1.0 = creative).
+     * @default 0.7
+     */
+    temperature?: number;
+    /**
+     * Top-K sampling (number of top tokens to consider).
+     * @default 40
+     */
+    topK?: number;
+    /**
+     * Top-P (nucleus) sampling threshold.
+     * @default 0.95
+     */
+    topP?: number;
+    /**
+     * Whether this is a multimodal model.
+     * When enabled, the engine handles image/audio tokens properly.
+     * If not specified, the system will fall back to filename sniffing.
+     */
+    multimodal?: boolean;
+    /**
+     * List of tools/functions that the model can call.
+     */
+    tools?: ToolDefinition[];
+    /**
+     * Whether to enable speculative decoding (multi-token prediction) if supported by the model.
+     * @default false
+     */
+    enableSpeculativeDecoding?: boolean;
+    /**
+     * Whether to enable thinking/reasoning mode.
+     * When enabled, the model generates internal reasoning before the final response.
+     * The thinking text is available in ExecuteResult.thinkingText and streamed via onThinkingToken.
+     * @default false
+     */
+    enableThinking?: boolean;
+}
+/**
+ * A simple message in the conversation.
+ * For multimodal, use sendMessageWithImage/sendMessageWithAudio instead.
+ */
+export interface Message {
+    /** Role of the message sender */
+    role: Role;
+    /** Text content of the message */
+    content: string;
+}
+/**
+ * Generation statistics returned after completion.
+ */
+export interface GenerationStats {
+    /** Number of tokens in the prompt */
+    promptTokens: number;
+    /** Number of tokens generated */
+    completionTokens: number;
+    /** Total tokens (prompt + completion) */
+    totalTokens: number;
+    /** Time to first token in milliseconds */
+    timeToFirstToken: number;
+    /** Total generation time in milliseconds */
+    totalTime: number;
+    /** Tokens per second */
+    tokensPerSecond: number;
+}
+/**
+ * Real memory usage statistics from the native runtime.
+ * Measured from OS-level APIs, not estimated.
+ */
+export interface MemoryUsage {
+    /** Native heap allocated bytes (Debug.getNativeHeapAllocatedSize on Android, malloc_size on iOS) */
+    nativeHeapBytes: number;
+    /** Total process resident set size (RSS) in bytes */
+    residentBytes: number;
+    /** Available system memory in bytes */
+    availableMemoryBytes: number;
+    /** Whether the system considers memory low */
+    isLowMemory: boolean;
+}
+/**
+ * LiteRT-LM: High-performance LLM inference engine.
+ * Supports Gemma 4, Gemma 3n, Phi-4, Qwen, and other .litertlm models.
+ *
+ * @example
+ * ```typescript
+ * const llm = createLLM();
+ * llm.loadModel('/path/to/gemma-4-E2B-it.litertlm', { backend: 'cpu' });
+ *
+ * // Blocking generation
+ * const response = llm.sendMessage('What is the capital of France?');
+ *
+ * // Streaming generation
+ * llm.sendMessageAsync('Tell me a story', (token, done) => {
+ *   process.stdout.write(token);
+ * });
+ *
+ * llm.close();
+ * ```
+ */
+export interface LiteRTLM extends HybridObject<{
+    ios: "swift";
+    android: "kotlin";
+}> {
+    /**
+     * Load a .litertlm model file.
+     * @param config Optional configuration for backend and sampling.
+     * @throws Error if the model cannot be loaded.
+     */
+    loadModel(modelPath: string, config?: LLMConfig): Promise<void>;
+    /**
+     * Send a text message and get the complete response (blocking).
+     * @param message User message text.
+     * @returns ExecuteResult with text and any tool calls.
+     */
+    sendMessage(message: string): Promise<ExecuteResult>;
+    /**
+     * Send a text message with an image (multimodal).
+     * @param message User message text.
+     * @param imagePath Absolute path to an image file.
+     * @returns ExecuteResult with text and any tool calls.
+     */
+    sendMessageWithImage(message: string, imagePath: string): Promise<ExecuteResult>;
+    /**
+     * Send a text message with an image and get a streaming response.
+     * Tokens are delivered via callback as they are generated.
+     * @param message User message text.
+     * @param imagePath Absolute path to an image file.
+     * @param onToken Callback invoked for each token (token, isDone).
+     */
+    sendMessageWithImageAsync(message: string, imagePath: string, onToken: (token: string, done: boolean) => void): Promise<void>;
+    /**
+     * Download a model file from a URL.
+     * @deprecated Use ModelRegistry instead.
+     */
+    downloadModel(url: string, fileName: string, onProgress?: (progress: number) => void): Promise<string>;
+    /**
+     * Delete a downloaded model file.
+     * @deprecated Use ModelRegistry instead.
+     */
+    deleteModel(fileName: string): Promise<void>;
+    /**
+     * Send a text message with audio (multimodal).
+     * @param message User message text.
+     * @param audioPath Absolute path to an audio file (WAV).
+     * @returns The model's response text.
+     */
+    sendMessageWithAudio(message: string, audioPath: string): Promise<ExecuteResult>;
+    /**
+     * Send a text message with audio and get a streaming response.
+     * Tokens are delivered via callback as they are generated.
+     * @param message User message text.
+     * @param audioPath Absolute path to an audio file (WAV).
+     * @param onToken Callback invoked for each token (token, isDone).
+     */
+    sendMessageWithAudioAsync(message: string, audioPath: string, onToken: (token: string, done: boolean) => void): Promise<void>;
+    /**
+     * Send a unified multimodal message containing text and/or zero-copy binary buffers.
+     * @param parts The message content parts (text, image, and/or audio).
+     * @returns The model's response text.
+     */
+    sendMultimodalMessage(parts: MultimodalPart[]): Promise<ExecuteResult>;
+    /**
+     * Send a message with streaming response.
+     * Tokens are delivered via callback as they are generated.
+     * @param message User message text.
+     * @param onToken Callback invoked for each token (token, isDone).
+     */
+    sendMessageAsync(message: string, onToken: (token: string, done: boolean) => void): Promise<void>;
+    /**
+     * Get the current conversation history.
+     * @returns Array of messages in the conversation.
+     */
+    getHistory(): Message[];
+    /**
+     * Clear the conversation context and start fresh.
+     */
+    resetConversation(): void;
+    /**
+     * Check if a model is loaded and ready for inference.
+     */
+    isReady(): boolean;
+    /**
+     * Get the last generation statistics.
+     */
+    getStats(): GenerationStats;
+    /**
+     * Count tokens in a text string. Returns -1 if unavailable.
+     */
+    countTokens(text: string): number;
+    /**
+     * Get real memory usage from the native runtime.
+     * Uses OS-level APIs to report actual memory consumption.
+     */
+    getMemoryUsage(): MemoryUsage;
+    /**
+     * Execute a unified multimodal inference request.
+     *
+     * A single deep entry point that replaces all modalality-specific send methods.
+     * Accepts text, image (path or buffer), and audio (path or buffer) parts.
+     * When onToken is provided, streams tokens incrementally; otherwise resolves
+     * with the complete response.
+     *
+     * @param parts Array of content parts (text, image, audio)
+     * @param onToken Optional streaming callback - invoked per token with (token, isDone)
+     * @returns Promise resolving to ExecuteResult with text and any tool calls
+     */
+    execute(parts: MultimodalPart[], onToken?: (token: string, done: boolean) => void): Promise<ExecuteResult>;
+    /**
+     * Send tool execution results back to the model to continue generation.
+     * Call this after receiving tool calls from execute() and executing them.
+     *
+     * @param responses Array of tool responses with name and result JSON
+     * @param onToken Optional streaming callback
+     * @returns Promise resolving to ExecuteResult (may contain further tool calls)
+     */
+    sendToolResponse(responses: ToolResponse[], onToken?: (token: string, done: boolean) => void): Promise<ExecuteResult>;
+    /**
+     * Get the backend the engine is actually using after initialization.
+     * If GPU was requested but unavailable, this returns 'cpu' after fallback.
+     * Returns the requested backend before loadModel is called.
+     */
+    getActiveBackend(): Backend;
+    /**
+     * Cancel any in-progress inference.
+     * Partial output generated so far is preserved.
+     * No-op if nothing is generating.
+     */
+    stopGeneration(): void;
+    /**
+     * Release all native resources.
+     * Call this when done with the LLM instance.
+     */
+    close(): void;
+}
+export interface ModelFile {
+    fileName: string;
+    absolutePath: string;
+    sizeBytes: number;
+    lastModifiedMs: number;
+}
+export interface ModelStore extends HybridObject<{
+    ios: "swift";
+    android: "kotlin";
+}> {
+    isCached(fileName: string): boolean;
+    getFilePath(fileName: string): string;
+    listCachedFiles(): ModelFile[];
+    deleteFile(fileName: string): void;
+    downloadFile(url: string, fileName: string, headersJson: string, onProgress: (progress: number) => void): Promise<string>;
+}

package/lib/specs/LiteRTLM.nitro.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/nitrogen/generated/.gitattributes

@@ -0,0 +1 @@
+** linguist-generated=true

package/nitrogen/generated/android/LiteRTLM+autolinking.cmake

@@ -0,0 +1,83 @@
+#
+# LiteRTLM+autolinking.cmake
+# This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+# https://github.com/mrousavy/nitro
+# Copyright © Marc Rousavy @ Margelo
+#
+
+# This is a CMake file that adds all files generated by Nitrogen
+# to the current CMake project.
+#
+# To use it, add this to your CMakeLists.txt:
+# ```cmake
+# include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/LiteRTLM+autolinking.cmake)
+# ```
+
+# Define a flag to check if we are building properly
+add_definitions(-DBUILDING_LITERTLM_WITH_GENERATED_CMAKE_PROJECT)
+
+# Enable Raw Props parsing in react-native (for Nitro Views)
+add_definitions(-DRN_SERIALIZABLE_STATE)
+
+# Add all headers that were generated by Nitrogen
+include_directories(
+  "../nitrogen/generated/shared/c++"
+  "../nitrogen/generated/android/c++"
+  "../nitrogen/generated/android/"
+)
+
+# Add all .cpp sources that were generated by Nitrogen
+target_sources(
+  # CMake project name (Android C++ library name)
+  LiteRTLM PRIVATE
+  # Autolinking Setup
+  ../nitrogen/generated/android/LiteRTLMOnLoad.cpp
+  # Shared Nitrogen C++ sources
+  ../nitrogen/generated/shared/c++/HybridLiteRTLMSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridModelStoreSpec.cpp
+  # Android-specific Nitrogen C++ sources
+  ../nitrogen/generated/android/c++/JHybridLiteRTLMSpec.cpp
+  ../nitrogen/generated/android/c++/JHybridModelStoreSpec.cpp
+)
+
+# From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake
+# Used in node_modules/react-native/ReactAndroid/cmake-utils/ReactNative-application.cmake
+target_compile_definitions(
+  LiteRTLM PRIVATE
+  -DFOLLY_NO_CONFIG=1
+  -DFOLLY_HAVE_CLOCK_GETTIME=1
+  -DFOLLY_USE_LIBCPP=1
+  -DFOLLY_CFG_NO_COROUTINES=1
+  -DFOLLY_MOBILE=1
+  -DFOLLY_HAVE_RECVMMSG=1
+  -DFOLLY_HAVE_PTHREAD=1
+  # Once we target android-23 above, we can comment
+  # the following line. NDK uses GNU style stderror_r() after API 23.
+  -DFOLLY_HAVE_XSI_STRERROR_R=1
+)
+
+# Add all libraries required by the generated specs
+find_package(fbjni REQUIRED) # <-- Used for communication between Java <-> C++
+find_package(ReactAndroid REQUIRED) # <-- Used to set up React Native bindings (e.g. CallInvoker/TurboModule)
+find_package(react-native-nitro-modules REQUIRED) # <-- Used to create all HybridObjects and use the Nitro core library
+
+# Link all libraries together
+target_link_libraries(
+        LiteRTLM
+        fbjni::fbjni                              # <-- Facebook C++ JNI helpers
+        ReactAndroid::jsi                         # <-- RN: JSI
+        react-native-nitro-modules::NitroModules  # <-- NitroModules Core :)
+)
+
+# Link react-native (different prefab between RN 0.75 and RN 0.76)
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+    target_link_libraries(
+        LiteRTLM
+        ReactAndroid::reactnative                 # <-- RN: Native Modules umbrella prefab
+    )
+else()
+    target_link_libraries(
+        LiteRTLM
+        ReactAndroid::react_nativemodule_core     # <-- RN: TurboModules Core
+    )
+endif()

package/nitrogen/generated/android/LiteRTLM+autolinking.gradle

@@ -0,0 +1,27 @@
+///
+/// LiteRTLM+autolinking.gradle
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/// This is a Gradle file that adds all files generated by Nitrogen
+/// to the current Gradle project.
+///
+/// To use it, add this to your build.gradle:
+/// ```gradle
+/// apply from: '../nitrogen/generated/android/LiteRTLM+autolinking.gradle'
+/// ```
+
+logger.warn("[NitroModules] 🔥 LiteRTLM is boosted by nitro!")
+
+android {
+  sourceSets {
+    main {
+      java.srcDirs += [
+        // Nitrogen files
+        "${project.projectDir}/../nitrogen/generated/android/kotlin"
+      ]
+    }
+  }
+}

package/nitrogen/generated/android/LiteRTLMOnLoad.cpp

@@ -0,0 +1,74 @@
+///
+/// LiteRTLMOnLoad.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#ifndef BUILDING_LITERTLM_WITH_GENERATED_CMAKE_PROJECT
+#error LiteRTLMOnLoad.cpp is not being built with the autogenerated CMakeLists.txt project. Is a different CMakeLists.txt building this?
+#endif
+
+#include "LiteRTLMOnLoad.hpp"
+
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#include <NitroModules/HybridObjectRegistry.hpp>
+
+#include "JHybridLiteRTLMSpec.hpp"
+#include "JFunc_void_std__string_bool.hpp"
+#include "JFunc_void_double.hpp"
+#include "JHybridModelStoreSpec.hpp"
+#include <NitroModules/DefaultConstructableObject.hpp>
+
+namespace margelo::nitro::litertlm {
+
+int initialize(JavaVM* vm) {
+  return facebook::jni::initialize(vm, []() {
+    ::margelo::nitro::litertlm::registerAllNatives();
+  });
+}
+
+struct JHybridLiteRTLMSpecImpl: public jni::JavaClass<JHybridLiteRTLMSpecImpl, JHybridLiteRTLMSpec::JavaPart> {
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/dev/litert/litertlm/HybridLiteRTLM;";
+  static std::shared_ptr<JHybridLiteRTLMSpec> create() {
+    static const auto constructorFn = javaClassStatic()->getConstructor<JHybridLiteRTLMSpecImpl::javaobject()>();
+    jni::local_ref<JHybridLiteRTLMSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->getJHybridLiteRTLMSpec();
+  }
+};
+struct JHybridModelStoreSpecImpl: public jni::JavaClass<JHybridModelStoreSpecImpl, JHybridModelStoreSpec::JavaPart> {
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/dev/litert/litertlm/HybridModelStore;";
+  static std::shared_ptr<JHybridModelStoreSpec> create() {
+    static const auto constructorFn = javaClassStatic()->getConstructor<JHybridModelStoreSpecImpl::javaobject()>();
+    jni::local_ref<JHybridModelStoreSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->getJHybridModelStoreSpec();
+  }
+};
+
+void registerAllNatives() {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::litertlm;
+
+  // Register native JNI methods
+  margelo::nitro::litertlm::JHybridLiteRTLMSpec::CxxPart::registerNatives();
+  margelo::nitro::litertlm::JFunc_void_std__string_bool_cxx::registerNatives();
+  margelo::nitro::litertlm::JFunc_void_double_cxx::registerNatives();
+  margelo::nitro::litertlm::JHybridModelStoreSpec::CxxPart::registerNatives();
+
+  // Register Nitro Hybrid Objects
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "LiteRTLM",
+    []() -> std::shared_ptr<HybridObject> {
+      return JHybridLiteRTLMSpecImpl::create();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "ModelStore",
+    []() -> std::shared_ptr<HybridObject> {
+      return JHybridModelStoreSpecImpl::create();
+    }
+  );
+}
+
+} // namespace margelo::nitro::litertlm

package/nitrogen/generated/android/LiteRTLMOnLoad.hpp

@@ -0,0 +1,34 @@
+///
+/// LiteRTLMOnLoad.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <jni.h>
+#include <functional>
+#include <NitroModules/NitroDefines.hpp>
+
+namespace margelo::nitro::litertlm {
+
+  [[deprecated("Use registerNatives() instead.")]]
+  int initialize(JavaVM* vm);
+
+  /**
+   * Register the native (C++) part of LiteRTLM, and autolinks all Hybrid Objects.
+   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`),
+   * inside a `facebook::jni::initialize(vm, ...)` call.
+   * Example:
+   * ```cpp (cpp-adapter.cpp)
+   * JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+   *   return facebook::jni::initialize(vm, []() {
+   *     // register all LiteRTLM HybridObjects
+   *     margelo::nitro::litertlm::registerNatives();
+   *     // any other custom registrations go here.
+   *   });
+   * }
+   * ```
+   */
+  void registerAllNatives();
+
+} // namespace margelo::nitro::litertlm

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

@@ -0,0 +1,61 @@
+///
+/// JBackend.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "Backend.hpp"
+
+namespace margelo::nitro::litertlm {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "Backend" and the the Kotlin enum "Backend".
+   */
+  struct JBackend final: public jni::JavaClass<JBackend> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/dev/litert/litertlm/Backend;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum Backend.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    Backend toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<Backend>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JBackend> fromCpp(Backend value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case Backend::CPU:
+          static const auto fieldCPU = clazz->getStaticField<JBackend>("CPU");
+          return clazz->getStaticFieldValue(fieldCPU);
+        case Backend::GPU:
+          static const auto fieldGPU = clazz->getStaticField<JBackend>("GPU");
+          return clazz->getStaticFieldValue(fieldGPU);
+        case Backend::NPU:
+          static const auto fieldNPU = clazz->getStaticField<JBackend>("NPU");
+          return clazz->getStaticFieldValue(fieldNPU);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::litertlm