@runanywhere/core 0.16.0

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,271 @@
+#include <jni.h>
+#include <string>
+#include <android/log.h>
+#include "runanywherecoreOnLoad.hpp"
+
+#define LOG_TAG "ArchiveJNI"
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+
+// Store JavaVM globally for JNI calls from background threads
+// NOT static - needs to be accessible from InitBridge.cpp for secure storage
+JavaVM* g_javaVM = nullptr;
+
+// Cache class and method references at JNI_OnLoad time
+// This is necessary because FindClass from native threads uses the system class loader
+static jclass g_archiveUtilityClass = nullptr;
+static jmethodID g_extractMethod = nullptr;
+
+// PlatformAdapterBridge class and methods for secure storage (used by InitBridge.cpp)
+// NOT static - needs to be accessible from InitBridge.cpp
+jclass g_platformAdapterBridgeClass = nullptr;
+jclass g_httpResponseClass = nullptr;  // Inner class for httpPostSync response
+jmethodID g_secureSetMethod = nullptr;
+jmethodID g_secureGetMethod = nullptr;
+jmethodID g_secureDeleteMethod = nullptr;
+jmethodID g_secureExistsMethod = nullptr;
+jmethodID g_getPersistentDeviceUUIDMethod = nullptr;
+jmethodID g_httpPostSyncMethod = nullptr;
+jmethodID g_getDeviceModelMethod = nullptr;
+jmethodID g_getOSVersionMethod = nullptr;
+jmethodID g_getChipNameMethod = nullptr;
+jmethodID g_getTotalMemoryMethod = nullptr;
+jmethodID g_getAvailableMemoryMethod = nullptr;
+jmethodID g_getCoreCountMethod = nullptr;
+jmethodID g_getArchitectureMethod = nullptr;
+jmethodID g_getGPUFamilyMethod = nullptr;
+jmethodID g_isTabletMethod = nullptr;
+// HttpResponse field IDs
+jfieldID g_httpResponse_successField = nullptr;
+jfieldID g_httpResponse_statusCodeField = nullptr;
+jfieldID g_httpResponse_responseBodyField = nullptr;
+jfieldID g_httpResponse_errorMessageField = nullptr;
+
+// Forward declaration
+extern "C" bool ArchiveUtility_extractAndroid(const char* archivePath, const char* destinationPath);
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  g_javaVM = vm;
+
+  // Get JNIEnv to cache class references
+  JNIEnv* env = nullptr;
+  if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) == JNI_OK && env != nullptr) {
+    // Find and cache the ArchiveUtility class
+    jclass localClass = env->FindClass("com/margelo/nitro/runanywhere/ArchiveUtility");
+    if (localClass != nullptr) {
+      // Create a global reference so it persists across JNI calls
+      g_archiveUtilityClass = (jclass)env->NewGlobalRef(localClass);
+      env->DeleteLocalRef(localClass);
+
+      // Cache the extract method
+      g_extractMethod = env->GetStaticMethodID(
+        g_archiveUtilityClass,
+        "extract",
+        "(Ljava/lang/String;Ljava/lang/String;)Z"
+      );
+
+      if (g_extractMethod != nullptr) {
+        LOGI("ArchiveUtility class and method cached successfully");
+      } else {
+        LOGE("Failed to find extract method in ArchiveUtility");
+        if (env->ExceptionCheck()) {
+          env->ExceptionClear();
+        }
+      }
+    } else {
+      LOGE("Failed to find ArchiveUtility class at JNI_OnLoad");
+      if (env->ExceptionCheck()) {
+        env->ExceptionClear();
+      }
+    }
+
+    // Find and cache the PlatformAdapterBridge class (for secure storage)
+    jclass platformClass = env->FindClass("com/margelo/nitro/runanywhere/PlatformAdapterBridge");
+    if (platformClass != nullptr) {
+      g_platformAdapterBridgeClass = (jclass)env->NewGlobalRef(platformClass);
+      env->DeleteLocalRef(platformClass);
+
+      // Cache all methods we need
+      g_secureSetMethod = env->GetStaticMethodID(g_platformAdapterBridgeClass, "secureSet", "(Ljava/lang/String;Ljava/lang/String;)Z");
+      g_secureGetMethod = env->GetStaticMethodID(g_platformAdapterBridgeClass, "secureGet", "(Ljava/lang/String;)Ljava/lang/String;");
+      g_secureDeleteMethod = env->GetStaticMethodID(g_platformAdapterBridgeClass, "secureDelete", "(Ljava/lang/String;)Z");
+      g_secureExistsMethod = env->GetStaticMethodID(g_platformAdapterBridgeClass, "secureExists", "(Ljava/lang/String;)Z");
+      g_getPersistentDeviceUUIDMethod = env->GetStaticMethodID(g_platformAdapterBridgeClass, "getPersistentDeviceUUID", "()Ljava/lang/String;");
+      g_httpPostSyncMethod = env->GetStaticMethodID(g_platformAdapterBridgeClass, "httpPostSync", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Lcom/margelo/nitro/runanywhere/PlatformAdapterBridge$HttpResponse;");
+      g_getDeviceModelMethod = env->GetStaticMethodID(g_platformAdapterBridgeClass, "getDeviceModel", "()Ljava/lang/String;");
+      g_getOSVersionMethod = env->GetStaticMethodID(g_platformAdapterBridgeClass, "getOSVersion", "()Ljava/lang/String;");
+      g_getChipNameMethod = env->GetStaticMethodID(g_platformAdapterBridgeClass, "getChipName", "()Ljava/lang/String;");
+      g_getTotalMemoryMethod = env->GetStaticMethodID(g_platformAdapterBridgeClass, "getTotalMemory", "()J");
+      g_getAvailableMemoryMethod = env->GetStaticMethodID(g_platformAdapterBridgeClass, "getAvailableMemory", "()J");
+      g_getCoreCountMethod = env->GetStaticMethodID(g_platformAdapterBridgeClass, "getCoreCount", "()I");
+      g_getArchitectureMethod = env->GetStaticMethodID(g_platformAdapterBridgeClass, "getArchitecture", "()Ljava/lang/String;");
+      g_getGPUFamilyMethod = env->GetStaticMethodID(g_platformAdapterBridgeClass, "getGPUFamily", "()Ljava/lang/String;");
+      g_isTabletMethod = env->GetStaticMethodID(g_platformAdapterBridgeClass, "isTablet", "()Z");
+
+      if (g_secureSetMethod && g_secureGetMethod && g_getPersistentDeviceUUIDMethod && 
+          g_getDeviceModelMethod && g_getOSVersionMethod && g_getChipNameMethod &&
+          g_getTotalMemoryMethod && g_getAvailableMemoryMethod && g_getCoreCountMethod && 
+          g_getArchitectureMethod && g_getGPUFamilyMethod && g_isTabletMethod) {
+        LOGI("PlatformAdapterBridge class and methods cached successfully");
+      } else {
+        LOGE("Failed to cache some PlatformAdapterBridge methods");
+        if (env->ExceptionCheck()) {
+          env->ExceptionClear();
+        }
+      }
+
+      // Cache HttpResponse inner class and its fields
+      jclass responseClass = env->FindClass("com/margelo/nitro/runanywhere/PlatformAdapterBridge$HttpResponse");
+      if (responseClass != nullptr) {
+        g_httpResponseClass = (jclass)env->NewGlobalRef(responseClass);
+        env->DeleteLocalRef(responseClass);
+
+        g_httpResponse_successField = env->GetFieldID(g_httpResponseClass, "success", "Z");
+        g_httpResponse_statusCodeField = env->GetFieldID(g_httpResponseClass, "statusCode", "I");
+        g_httpResponse_responseBodyField = env->GetFieldID(g_httpResponseClass, "responseBody", "Ljava/lang/String;");
+        g_httpResponse_errorMessageField = env->GetFieldID(g_httpResponseClass, "errorMessage", "Ljava/lang/String;");
+
+        if (g_httpResponse_successField && g_httpResponse_statusCodeField) {
+          LOGI("HttpResponse class and fields cached successfully");
+        } else {
+          LOGE("Failed to cache HttpResponse fields");
+        }
+      } else {
+        LOGE("Failed to find HttpResponse inner class at JNI_OnLoad");
+        if (env->ExceptionCheck()) {
+          env->ExceptionClear();
+        }
+      }
+    } else {
+      LOGE("Failed to find PlatformAdapterBridge class at JNI_OnLoad");
+      if (env->ExceptionCheck()) {
+        env->ExceptionClear();
+      }
+    }
+  }
+
+  return margelo::nitro::runanywhere::initialize(vm);
+}
+
+/**
+ * Get JNIEnv for the current thread
+ * Attaches thread if not already attached
+ */
+static JNIEnv* getJNIEnv() {
+    JNIEnv* env = nullptr;
+    if (g_javaVM == nullptr) {
+        LOGE("JavaVM is null");
+        return nullptr;
+    }
+
+    int status = g_javaVM->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6);
+    if (status == JNI_EDETACHED) {
+        if (g_javaVM->AttachCurrentThread(&env, nullptr) != JNI_OK) {
+            LOGE("Failed to attach thread");
+            return nullptr;
+        }
+        LOGI("Attached thread to JVM");
+    } else if (status != JNI_OK) {
+        LOGE("Failed to get JNIEnv, status=%d", status);
+        return nullptr;
+    }
+    return env;
+}
+
+/**
+ * Log Java exception details before clearing
+ */
+static void logAndClearException(JNIEnv* env, const char* context) {
+    if (env->ExceptionCheck()) {
+        jthrowable exception = env->ExceptionOccurred();
+        env->ExceptionClear();
+
+        // Get exception message
+        jclass throwableClass = env->FindClass("java/lang/Throwable");
+        if (throwableClass) {
+            jmethodID getMessageMethod = env->GetMethodID(throwableClass, "getMessage", "()Ljava/lang/String;");
+            if (getMessageMethod) {
+                jstring messageStr = (jstring)env->CallObjectMethod(exception, getMessageMethod);
+                if (messageStr) {
+                    const char* message = env->GetStringUTFChars(messageStr, nullptr);
+                    LOGE("[%s] Java exception: %s", context, message);
+                    env->ReleaseStringUTFChars(messageStr, message);
+                    env->DeleteLocalRef(messageStr);
+                } else {
+                    LOGE("[%s] Java exception (no message)", context);
+                }
+            }
+            env->DeleteLocalRef(throwableClass);
+        }
+
+        // Also print stack trace to logcat
+        jclass exceptionClass = env->GetObjectClass(exception);
+        if (exceptionClass) {
+            jmethodID printStackTraceMethod = env->GetMethodID(exceptionClass, "printStackTrace", "()V");
+            if (printStackTraceMethod) {
+                env->CallVoidMethod(exception, printStackTraceMethod);
+                env->ExceptionClear(); // Clear any exception from printStackTrace
+            }
+            env->DeleteLocalRef(exceptionClass);
+        }
+
+        env->DeleteLocalRef(exception);
+    }
+}
+
+/**
+ * Call Kotlin ArchiveUtility.extract() via JNI
+ * Uses cached class and method references from JNI_OnLoad
+ */
+extern "C" bool ArchiveUtility_extractAndroid(const char* archivePath, const char* destinationPath) {
+    LOGI("Starting extraction: %s -> %s", archivePath, destinationPath);
+
+    // Check if class and method were cached
+    if (g_archiveUtilityClass == nullptr || g_extractMethod == nullptr) {
+        LOGE("ArchiveUtility class or method not cached. JNI_OnLoad may have failed.");
+        return false;
+    }
+
+    JNIEnv* env = getJNIEnv();
+    if (env == nullptr) {
+        LOGE("Failed to get JNIEnv");
+        return false;
+    }
+
+    LOGI("Using cached ArchiveUtility class and method");
+
+    // Create Java strings
+    jstring jArchivePath = env->NewStringUTF(archivePath);
+    jstring jDestinationPath = env->NewStringUTF(destinationPath);
+
+    if (jArchivePath == nullptr || jDestinationPath == nullptr) {
+        LOGE("Failed to create Java strings");
+        if (jArchivePath) env->DeleteLocalRef(jArchivePath);
+        if (jDestinationPath) env->DeleteLocalRef(jDestinationPath);
+        return false;
+    }
+
+    // Call the method using cached references
+    LOGI("Calling ArchiveUtility.extract()...");
+    jboolean result = env->CallStaticBooleanMethod(
+        g_archiveUtilityClass,
+        g_extractMethod,
+        jArchivePath,
+        jDestinationPath
+    );
+
+    // Check for exceptions
+    if (env->ExceptionCheck()) {
+        LOGE("Exception during extraction");
+        logAndClearException(env, "extract");
+        result = JNI_FALSE;
+    } else {
+        LOGI("Extraction returned: %s", result ? "true" : "false");
+    }
+
+    // Cleanup local references
+    env->DeleteLocalRef(jArchivePath);
+    env->DeleteLocalRef(jDestinationPath);
+
+    return result == JNI_TRUE;
+}

package/android/src/main/include/rac/backends/rac_llm_llamacpp.h

@@ -0,0 +1,218 @@
+/**
+ * @file rac_llm_llamacpp.h
+ * @brief RunAnywhere Core - LlamaCPP Backend RAC API
+ *
+ * Direct RAC API export from runanywhere-core's LlamaCPP backend.
+ * This header defines the public C API for LLM inference using llama.cpp.
+ *
+ * Mirrors Swift's LlamaCPPService implementation pattern.
+ */
+
+#ifndef RAC_LLM_LLAMACPP_H
+#define RAC_LLM_LLAMACPP_H
+
+#include "rac/core/rac_error.h"
+#include "rac/core/rac_types.h"
+#include "rac/features/llm/rac_llm.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// =============================================================================
+// EXPORT MACRO
+// =============================================================================
+
+#if defined(RAC_LLAMACPP_BUILDING)
+#if defined(_WIN32)
+#define RAC_LLAMACPP_API __declspec(dllexport)
+#elif defined(__GNUC__) || defined(__clang__)
+#define RAC_LLAMACPP_API __attribute__((visibility("default")))
+#else
+#define RAC_LLAMACPP_API
+#endif
+#else
+#define RAC_LLAMACPP_API
+#endif
+
+// =============================================================================
+// CONFIGURATION - Mirrors Swift's LlamaCPPGenerationConfig
+// =============================================================================
+
+/**
+ * LlamaCPP-specific configuration.
+ *
+ * Mirrors Swift's LlamaCPPGenerationConfig.
+ */
+typedef struct rac_llm_llamacpp_config {
+    /** Context size (0 = auto-detect from model) */
+    int32_t context_size;
+
+    /** Number of threads (0 = auto-detect) */
+    int32_t num_threads;
+
+    /** Number of layers to offload to GPU (Metal on iOS/macOS) */
+    int32_t gpu_layers;
+
+    /** Batch size for prompt processing */
+    int32_t batch_size;
+} rac_llm_llamacpp_config_t;
+
+/**
+ * Default LlamaCPP configuration.
+ */
+static const rac_llm_llamacpp_config_t RAC_LLM_LLAMACPP_CONFIG_DEFAULT = {
+    .context_size = 0,  // Auto-detect
+    .num_threads = 0,   // Auto-detect
+    .gpu_layers = -1,   // All layers on GPU
+    .batch_size = 512};
+
+// =============================================================================
+// LLAMACPP-SPECIFIC API
+// =============================================================================
+
+/**
+ * Creates a LlamaCPP LLM service.
+ *
+ * Mirrors Swift's LlamaCPPService.initialize(modelPath:)
+ *
+ * @param model_path Path to the GGUF model file
+ * @param config LlamaCPP-specific configuration (can be NULL for defaults)
+ * @param out_handle Output: Handle to the created service
+ * @return RAC_SUCCESS or error code
+ */
+RAC_LLAMACPP_API rac_result_t rac_llm_llamacpp_create(const char* model_path,
+                                                      const rac_llm_llamacpp_config_t* config,
+                                                      rac_handle_t* out_handle);
+
+/**
+ * Loads a GGUF model into an existing service.
+ *
+ * Mirrors Swift's LlamaCPPService.loadModel(path:config:)
+ *
+ * @param handle Service handle
+ * @param model_path Path to the GGUF model file
+ * @param config LlamaCPP configuration (can be NULL)
+ * @return RAC_SUCCESS or error code
+ */
+RAC_LLAMACPP_API rac_result_t rac_llm_llamacpp_load_model(rac_handle_t handle,
+                                                          const char* model_path,
+                                                          const rac_llm_llamacpp_config_t* config);
+
+/**
+ * Unloads the current model.
+ *
+ * Mirrors Swift's LlamaCPPService.unloadModel()
+ *
+ * @param handle Service handle
+ * @return RAC_SUCCESS or error code
+ */
+RAC_LLAMACPP_API rac_result_t rac_llm_llamacpp_unload_model(rac_handle_t handle);
+
+/**
+ * Checks if a model is loaded.
+ *
+ * Mirrors Swift's LlamaCPPService.isModelLoaded
+ *
+ * @param handle Service handle
+ * @return RAC_TRUE if model is loaded, RAC_FALSE otherwise
+ */
+RAC_LLAMACPP_API rac_bool_t rac_llm_llamacpp_is_model_loaded(rac_handle_t handle);
+
+/**
+ * Generates text completion.
+ *
+ * Mirrors Swift's LlamaCPPService.generate(prompt:config:)
+ *
+ * @param handle Service handle
+ * @param prompt Input prompt text
+ * @param options Generation options (can be NULL for defaults)
+ * @param out_result Output: Generation result (caller must free text with rac_free)
+ * @return RAC_SUCCESS or error code
+ */
+RAC_LLAMACPP_API rac_result_t rac_llm_llamacpp_generate(rac_handle_t handle, const char* prompt,
+                                                        const rac_llm_options_t* options,
+                                                        rac_llm_result_t* out_result);
+
+/**
+ * Streaming text generation callback.
+ *
+ * Mirrors Swift's streaming callback pattern.
+ *
+ * @param token Generated token string
+ * @param is_final Whether this is the final token
+ * @param user_data User-provided context
+ * @return RAC_TRUE to continue, RAC_FALSE to stop
+ */
+typedef rac_bool_t (*rac_llm_llamacpp_stream_callback_fn)(const char* token, rac_bool_t is_final,
+                                                          void* user_data);
+
+/**
+ * Generates text with streaming callback.
+ *
+ * Mirrors Swift's LlamaCPPService.generateStream(prompt:config:)
+ *
+ * @param handle Service handle
+ * @param prompt Input prompt text
+ * @param options Generation options
+ * @param callback Callback for each token
+ * @param user_data User context passed to callback
+ * @return RAC_SUCCESS or error code
+ */
+RAC_LLAMACPP_API rac_result_t rac_llm_llamacpp_generate_stream(
+    rac_handle_t handle, const char* prompt, const rac_llm_options_t* options,
+    rac_llm_llamacpp_stream_callback_fn callback, void* user_data);
+
+/**
+ * Cancels ongoing generation.
+ *
+ * Mirrors Swift's LlamaCPPService.cancel()
+ *
+ * @param handle Service handle
+ */
+RAC_LLAMACPP_API void rac_llm_llamacpp_cancel(rac_handle_t handle);
+
+/**
+ * Gets model information as JSON.
+ *
+ * @param handle Service handle
+ * @param out_json Output: JSON string (caller must free with rac_free)
+ * @return RAC_SUCCESS or error code
+ */
+RAC_LLAMACPP_API rac_result_t rac_llm_llamacpp_get_model_info(rac_handle_t handle, char** out_json);
+
+/**
+ * Destroys a LlamaCPP LLM service.
+ *
+ * @param handle Service handle to destroy
+ */
+RAC_LLAMACPP_API void rac_llm_llamacpp_destroy(rac_handle_t handle);
+
+// =============================================================================
+// BACKEND REGISTRATION
+// =============================================================================
+
+/**
+ * Registers the LlamaCPP backend with the commons module and service registries.
+ *
+ * Should be called once during SDK initialization.
+ * This registers:
+ * - Module: "llamacpp" with TEXT_GENERATION capability
+ * - Service provider: LlamaCPP LLM provider
+ *
+ * @return RAC_SUCCESS or error code
+ */
+RAC_LLAMACPP_API rac_result_t rac_backend_llamacpp_register(void);
+
+/**
+ * Unregisters the LlamaCPP backend.
+ *
+ * @return RAC_SUCCESS or error code
+ */
+RAC_LLAMACPP_API rac_result_t rac_backend_llamacpp_unregister(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* RAC_LLM_LLAMACPP_H */

package/android/src/main/include/rac/backends/rac_stt_onnx.h

@@ -0,0 +1,99 @@
+/**
+ * @file rac_stt_onnx.h
+ * @brief RunAnywhere Core - ONNX Backend RAC API for STT
+ *
+ * Direct RAC API export from runanywhere-core's ONNX STT backend.
+ * Mirrors Swift's ONNXSTTService implementation pattern.
+ */
+
+#ifndef RAC_STT_ONNX_H
+#define RAC_STT_ONNX_H
+
+#include "rac/core/rac_error.h"
+#include "rac/core/rac_types.h"
+#include "rac/features/stt/rac_stt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// =============================================================================
+// EXPORT MACRO
+// =============================================================================
+
+#if defined(RAC_ONNX_BUILDING)
+#if defined(_WIN32)
+#define RAC_ONNX_API __declspec(dllexport)
+#elif defined(__GNUC__) || defined(__clang__)
+#define RAC_ONNX_API __attribute__((visibility("default")))
+#else
+#define RAC_ONNX_API
+#endif
+#else
+#define RAC_ONNX_API
+#endif
+
+// =============================================================================
+// CONFIGURATION
+// =============================================================================
+
+/**
+ * ONNX STT model types.
+ */
+typedef enum rac_stt_onnx_model_type {
+    RAC_STT_ONNX_MODEL_WHISPER = 0,
+    RAC_STT_ONNX_MODEL_ZIPFORMER = 1,
+    RAC_STT_ONNX_MODEL_PARAFORMER = 2,
+    RAC_STT_ONNX_MODEL_AUTO = 99
+} rac_stt_onnx_model_type_t;
+
+/**
+ * ONNX STT configuration.
+ */
+typedef struct rac_stt_onnx_config {
+    rac_stt_onnx_model_type_t model_type;
+    int32_t num_threads;
+    rac_bool_t use_coreml;
+} rac_stt_onnx_config_t;
+
+static const rac_stt_onnx_config_t RAC_STT_ONNX_CONFIG_DEFAULT = {
+    .model_type = RAC_STT_ONNX_MODEL_AUTO, .num_threads = 0, .use_coreml = RAC_TRUE};
+
+// =============================================================================
+// ONNX STT API
+// =============================================================================
+
+RAC_ONNX_API rac_result_t rac_stt_onnx_create(const char* model_path,
+                                              const rac_stt_onnx_config_t* config,
+                                              rac_handle_t* out_handle);
+
+RAC_ONNX_API rac_result_t rac_stt_onnx_transcribe(rac_handle_t handle, const float* audio_samples,
+                                                  size_t num_samples,
+                                                  const rac_stt_options_t* options,
+                                                  rac_stt_result_t* out_result);
+
+RAC_ONNX_API rac_bool_t rac_stt_onnx_supports_streaming(rac_handle_t handle);
+
+RAC_ONNX_API rac_result_t rac_stt_onnx_create_stream(rac_handle_t handle, rac_handle_t* out_stream);
+
+RAC_ONNX_API rac_result_t rac_stt_onnx_feed_audio(rac_handle_t handle, rac_handle_t stream,
+                                                  const float* audio_samples, size_t num_samples);
+
+RAC_ONNX_API rac_bool_t rac_stt_onnx_stream_is_ready(rac_handle_t handle, rac_handle_t stream);
+
+RAC_ONNX_API rac_result_t rac_stt_onnx_decode_stream(rac_handle_t handle, rac_handle_t stream,
+                                                     char** out_text);
+
+RAC_ONNX_API void rac_stt_onnx_input_finished(rac_handle_t handle, rac_handle_t stream);
+
+RAC_ONNX_API rac_bool_t rac_stt_onnx_is_endpoint(rac_handle_t handle, rac_handle_t stream);
+
+RAC_ONNX_API void rac_stt_onnx_destroy_stream(rac_handle_t handle, rac_handle_t stream);
+
+RAC_ONNX_API void rac_stt_onnx_destroy(rac_handle_t handle);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* RAC_STT_ONNX_H */