cactus-react-native 1.5.0 → 1.7.0

package/android/CMakeLists.txt

@@ -9,7 +9,6 @@ set(CMAKE_CXX_STANDARD 20)
 add_library(${PACKAGE_NAME} SHARED
     src/main/cpp/cpp-adapter.cpp
     ../cpp/HybridCactus.cpp
-    ../cpp/HybridCactusUtil.cpp
     ../cpp/HybridCactusIndex.cpp
 )
 
@@ -18,9 +17,26 @@ set_target_properties(libcactus PROPERTIES
     IMPORTED_LOCATION "${CMAKE_CURRENT_LIST_DIR}/src/main/jniLibs/${ANDROID_ABI}/libcactus.a"
 )
 
-add_library(libcactus_util STATIC IMPORTED)
-set_target_properties(libcactus_util PROPERTIES
-    IMPORTED_LOCATION "${CMAKE_CURRENT_LIST_DIR}/src/main/jniLibs/${ANDROID_ABI}/libcactus_util.a"
+set(JNILIBS_DIR "${CMAKE_CURRENT_LIST_DIR}/src/main/jniLibs/${ANDROID_ABI}")
+
+add_library(libcurl STATIC IMPORTED)
+set_target_properties(libcurl PROPERTIES
+    IMPORTED_LOCATION "${JNILIBS_DIR}/libcurl.a"
+)
+
+add_library(libmbedtls STATIC IMPORTED)
+set_target_properties(libmbedtls PROPERTIES
+    IMPORTED_LOCATION "${JNILIBS_DIR}/libmbedtls.a"
+)
+
+add_library(libmbedx509 STATIC IMPORTED)
+set_target_properties(libmbedx509 PROPERTIES
+    IMPORTED_LOCATION "${JNILIBS_DIR}/libmbedx509.a"
+)
+
+add_library(libmbedcrypto STATIC IMPORTED)
+set_target_properties(libmbedcrypto PROPERTIES
+    IMPORTED_LOCATION "${JNILIBS_DIR}/libmbedcrypto.a"
 )
 
 # Add Nitrogen specs :)
@@ -37,5 +53,8 @@ target_link_libraries(
         ${LOG_LIB}
         android # <-- Android core
         libcactus
-        libcactus_util
+        libcurl
+        libmbedtls
+        libmbedx509
+        libmbedcrypto
 )

package/cpp/HybridCactus.cpp

@@ -5,10 +5,11 @@ namespace margelo::nitro::cactus {
 HybridCactus::HybridCactus() : HybridObject(TAG) {}
 
 std::shared_ptr<Promise<void>>
-HybridCactus::init(const std::string &modelPath, double contextSize,
-                   const std::optional<std::string> &corpusDir) {
+HybridCactus::init(const std::string &modelPath,
+                   const std::optional<std::string> &corpusDir,
+                   std::optional<bool> cacheIndex) {
   return Promise<void>::async(
-      [this, modelPath, contextSize, corpusDir]() -> void {
+      [this, modelPath, corpusDir, cacheIndex]() -> void {
         std::lock_guard<std::mutex> lock(this->_modelMutex);
 
         if (this->_model) {
@@ -16,8 +17,9 @@ HybridCactus::init(const std::string &modelPath, double contextSize,
         }
 
         const cactus_model_t model =
-            cactus_init(modelPath.c_str(), contextSize,
-                        corpusDir ? corpusDir->c_str() : nullptr);
+            cactus_init(modelPath.c_str(),
+                        corpusDir ? corpusDir->c_str() : nullptr,
+                        cacheIndex.value_or(false));
 
         if (!model) {
           throw std::runtime_error("Cactus init failed: " +
@@ -25,7 +27,6 @@ HybridCactus::init(const std::string &modelPath, double contextSize,
         }
 
         this->_model = model;
-        this->_contextSize = contextSize;
       });
 }
 
@@ -211,6 +212,144 @@ std::shared_ptr<Promise<std::string>> HybridCactus::transcribe(
   });
 }
 
+std::shared_ptr<Promise<void>> HybridCactus::streamTranscribeStart(
+    const std::optional<std::string> &optionsJson) {
+  return Promise<void>::async([this, optionsJson]() -> void {
+    std::lock_guard<std::mutex> lock(this->_modelMutex);
+
+    if (!this->_model) {
+      throw std::runtime_error("Cactus model is not initialized");
+    }
+
+    if (this->_streamTranscribe) {
+      throw std::runtime_error(
+          "Cactus stream transcribe is already initialized");
+    }
+
+    this->_streamTranscribe = cactus_stream_transcribe_start(
+        this->_model, optionsJson ? optionsJson->c_str() : nullptr);
+    if (!this->_streamTranscribe) {
+      throw std::runtime_error("Cactus stream transcribe start failed: " +
+                               std::string(cactus_get_last_error()));
+    }
+  });
+}
+
+std::shared_ptr<Promise<std::string>>
+HybridCactus::streamTranscribeProcess(const std::vector<double> &audio) {
+  return Promise<std::string>::async([this, audio]() -> std::string {
+    std::lock_guard<std::mutex> lock(this->_modelMutex);
+
+    if (!this->_streamTranscribe) {
+      throw std::runtime_error("Cactus stream transcribe is not initialized");
+    }
+
+    std::vector<uint8_t> audioBytes;
+    audioBytes.reserve(audio.size());
+    for (double d : audio) {
+      d = std::clamp(d, 0.0, 255.0);
+      audioBytes.emplace_back(static_cast<uint8_t>(d));
+    }
+
+    std::string responseBuffer;
+    responseBuffer.resize(32768);
+
+    int result = cactus_stream_transcribe_process(
+        this->_streamTranscribe, audioBytes.data(), audioBytes.size(),
+        responseBuffer.data(), responseBuffer.size());
+
+    if (result < 0) {
+      throw std::runtime_error("Cactus stream transcribe process failed: " +
+                               std::string(cactus_get_last_error()));
+    }
+
+    // Remove null terminator
+    responseBuffer.resize(strlen(responseBuffer.c_str()));
+
+    return responseBuffer;
+  });
+}
+
+std::shared_ptr<Promise<std::string>> HybridCactus::streamTranscribeStop() {
+  return Promise<std::string>::async([this]() -> std::string {
+    std::lock_guard<std::mutex> lock(this->_modelMutex);
+
+    if (!this->_streamTranscribe) {
+      throw std::runtime_error("Cactus stream transcribe is not initialized");
+    }
+
+    std::string responseBuffer;
+    responseBuffer.resize(32768);
+
+    int result = cactus_stream_transcribe_stop(
+        this->_streamTranscribe, responseBuffer.data(), responseBuffer.size());
+
+    this->_streamTranscribe = nullptr;
+
+    if (result < 0) {
+      throw std::runtime_error("Cactus stream transcribe stop failed: " +
+                               std::string(cactus_get_last_error()));
+    }
+
+    // Remove null terminator
+    responseBuffer.resize(strlen(responseBuffer.c_str()));
+
+    return responseBuffer;
+  });
+}
+
+std::shared_ptr<Promise<std::string>>
+HybridCactus::vad(const std::variant<std::vector<double>, std::string> &audio,
+                  double responseBufferSize,
+                  const std::optional<std::string> &optionsJson) {
+  return Promise<std::string>::async(
+      [this, audio, responseBufferSize, optionsJson]() -> std::string {
+        std::lock_guard<std::mutex> lock(this->_modelMutex);
+
+        if (!this->_model) {
+          throw std::runtime_error("Cactus model is not initialized");
+        }
+
+        std::string responseBuffer;
+        responseBuffer.resize(responseBufferSize);
+
+        int result;
+        if (std::holds_alternative<std::string>(audio)) {
+          result =
+              cactus_vad(this->_model,
+                         std::get<std::string>(audio).c_str(),
+                         responseBuffer.data(), responseBufferSize,
+                         optionsJson ? optionsJson->c_str() : nullptr,
+                         nullptr, 0);
+        } else {
+          const auto &audioDoubles = std::get<std::vector<double>>(audio);
+
+          std::vector<uint8_t> audioBytes;
+          audioBytes.reserve(audioDoubles.size());
+          for (double d : audioDoubles) {
+            d = std::clamp(d, 0.0, 255.0);
+            audioBytes.emplace_back(static_cast<uint8_t>(d));
+          }
+
+          result =
+              cactus_vad(this->_model, nullptr,
+                         responseBuffer.data(), responseBufferSize,
+                         optionsJson ? optionsJson->c_str() : nullptr,
+                         audioBytes.data(), audioBytes.size());
+        }
+
+        if (result < 0) {
+          throw std::runtime_error("Cactus VAD failed: " +
+                                   std::string(cactus_get_last_error()));
+        }
+
+        // Remove null terminator
+        responseBuffer.resize(strlen(responseBuffer.c_str()));
+
+        return responseBuffer;
+      });
+}
+
 std::shared_ptr<Promise<std::vector<double>>>
 HybridCactus::embed(const std::string &text, double embeddingBufferSize,
                     bool normalize) {
@@ -326,7 +465,7 @@ std::shared_ptr<Promise<void>> HybridCactus::destroy() {
     }
 
     if (this->_streamTranscribe) {
-      cactus_stream_transcribe_destroy(this->_streamTranscribe);
+      cactus_stream_transcribe_stop(this->_streamTranscribe, nullptr, 0);
       this->_streamTranscribe = nullptr;
     }
 
@@ -335,117 +474,10 @@ std::shared_ptr<Promise<void>> HybridCactus::destroy() {
   });
 }
 
-std::shared_ptr<Promise<void>> HybridCactus::streamTranscribeInit() {
-  return Promise<void>::async([this]() -> void {
-    std::lock_guard<std::mutex> lock(this->_modelMutex);
-
-    if (!this->_model) {
-      throw std::runtime_error("Cactus model is not initialized");
-    }
-
-    if (this->_streamTranscribe) {
-      throw std::runtime_error(
-          "Cactus stream transcribe is already initialized");
-    }
-
-    this->_streamTranscribe = cactus_stream_transcribe_init(this->_model);
-    if (!this->_streamTranscribe) {
-      throw std::runtime_error("Cactus stream transcribe init failed: " +
-                               std::string(cactus_get_last_error()));
-    }
-  });
-}
-
 std::shared_ptr<Promise<void>>
-HybridCactus::streamTranscribeInsert(const std::vector<double> &audio) {
-  return Promise<void>::async([this, audio]() -> void {
-    std::lock_guard<std::mutex> lock(this->_modelMutex);
-
-    if (!this->_streamTranscribe) {
-      throw std::runtime_error("Cactus stream transcribe is not initialized");
-    }
-
-    std::vector<uint8_t> audioBytes;
-    audioBytes.reserve(audio.size());
-    for (double d : audio) {
-      d = std::clamp(d, 0.0, 255.0);
-      audioBytes.emplace_back(static_cast<uint8_t>(d));
-    }
-
-    int result = cactus_stream_transcribe_insert(
-        this->_streamTranscribe, audioBytes.data(), audioBytes.size());
-
-    if (result < 0) {
-      throw std::runtime_error("Cactus stream transcribe insert failed: " +
-                               std::string(cactus_get_last_error()));
-    }
-  });
-}
-
-std::shared_ptr<Promise<std::string>> HybridCactus::streamTranscribeProcess(
-    const std::optional<std::string> &optionsJson) {
-  return Promise<std::string>::async([this, optionsJson]() -> std::string {
-    std::lock_guard<std::mutex> lock(this->_modelMutex);
-
-    if (!this->_streamTranscribe) {
-      throw std::runtime_error("Cactus stream transcribe is not initialized");
-    }
-
-    std::string responseBuffer;
-    responseBuffer.resize(32768);
-
-    int result = cactus_stream_transcribe_process(
-        this->_streamTranscribe, responseBuffer.data(), responseBuffer.size(),
-        optionsJson ? optionsJson->c_str() : nullptr);
-
-    if (result < 0) {
-      throw std::runtime_error("Cactus stream transcribe process failed: " +
-                               std::string(cactus_get_last_error()));
-    }
-
-    // Remove null terminator
-    responseBuffer.resize(strlen(responseBuffer.c_str()));
-
-    return responseBuffer;
-  });
-}
-
-std::shared_ptr<Promise<std::string>> HybridCactus::streamTranscribeFinalize() {
-  return Promise<std::string>::async([this]() -> std::string {
-    std::lock_guard<std::mutex> lock(this->_modelMutex);
-
-    if (!this->_streamTranscribe) {
-      throw std::runtime_error("Cactus stream transcribe is not initialized");
-    }
-
-    std::string responseBuffer;
-    responseBuffer.resize(32768);
-
-    int result = cactus_stream_transcribe_finalize(
-        this->_streamTranscribe, responseBuffer.data(), responseBuffer.size());
-
-    if (result < 0) {
-      throw std::runtime_error("Cactus stream transcribe finalize failed: " +
-                               std::string(cactus_get_last_error()));
-    }
-
-    // Remove null terminator
-    responseBuffer.resize(strlen(responseBuffer.c_str()));
-
-    return responseBuffer;
-  });
-}
-
-std::shared_ptr<Promise<void>> HybridCactus::streamTranscribeDestroy() {
-  return Promise<void>::async([this]() -> void {
-    std::lock_guard<std::mutex> lock(this->_modelMutex);
-
-    if (!this->_streamTranscribe) {
-      throw std::runtime_error("Cactus stream transcribe is not initialized");
-    }
-
-    cactus_stream_transcribe_destroy(this->_streamTranscribe);
-    this->_streamTranscribe = nullptr;
+HybridCactus::setTelemetryEnvironment(const std::string &cacheDir) {
+  return Promise<void>::async([cacheDir]() -> void {
+    cactus_set_telemetry_environment("react-native-v1.7", cacheDir.c_str());
   });
 }
 

package/cpp/HybridCactus.hpp

@@ -12,8 +12,9 @@ public:
   HybridCactus();
 
   std::shared_ptr<Promise<void>>
-  init(const std::string &modelPath, double contextSize,
-       const std::optional<std::string> &corpusDir) override;
+  init(const std::string &modelPath,
+       const std::optional<std::string> &corpusDir,
+       std::optional<bool> cacheIndex) override;
 
   std::shared_ptr<Promise<std::string>> complete(
       const std::string &messagesJson, double responseBufferSize,
@@ -38,17 +39,18 @@ public:
                                              double /* tokenId */)>> &callback)
       override;
 
-  std::shared_ptr<Promise<void>> streamTranscribeInit() override;
-
   std::shared_ptr<Promise<void>>
-  streamTranscribeInsert(const std::vector<double> &audio) override;
+  streamTranscribeStart(const std::optional<std::string> &optionsJson) override;
 
-  std::shared_ptr<Promise<std::string>> streamTranscribeProcess(
-      const std::optional<std::string> &optionsJson) override;
+  std::shared_ptr<Promise<std::string>>
+  streamTranscribeProcess(const std::vector<double> &audio) override;
 
-  std::shared_ptr<Promise<std::string>> streamTranscribeFinalize() override;
+  std::shared_ptr<Promise<std::string>> streamTranscribeStop() override;
 
-  std::shared_ptr<Promise<void>> streamTranscribeDestroy() override;
+  std::shared_ptr<Promise<std::string>>
+  vad(const std::variant<std::vector<double>, std::string> &audio,
+      double responseBufferSize,
+      const std::optional<std::string> &optionsJson) override;
 
   std::shared_ptr<Promise<std::vector<double>>>
   embed(const std::string &text, double embeddingBufferSize,
@@ -66,10 +68,12 @@ public:
 
   std::shared_ptr<Promise<void>> destroy() override;
 
+  std::shared_ptr<Promise<void>>
+  setTelemetryEnvironment(const std::string &cacheDir) override;
+
 private:
   cactus_model_t _model = nullptr;
   cactus_stream_transcribe_t _streamTranscribe = nullptr;
-  size_t _contextSize;
 
   std::mutex _modelMutex;
 };

package/cpp/cactus_ffi.h

@@ -6,11 +6,11 @@
 #include <stdbool.h>
 
 #if __GNUC__ >= 4
-  #define CACTUS_FFI_EXPORT __attribute__ ((visibility ("default")))
-  #define CACTUS_FFI_LOCAL  __attribute__ ((visibility ("hidden")))
+    #define CACTUS_FFI_EXPORT __attribute__((visibility("default")))
+    #define CACTUS_FFI_LOCAL  __attribute__((visibility("hidden")))
 #else
-  #define CACTUS_FFI_EXPORT
-  #define CACTUS_FFI_LOCAL
+    #define CACTUS_FFI_EXPORT
+    #define CACTUS_FFI_LOCAL
 #endif
 
 #ifdef __cplusplus
@@ -18,20 +18,30 @@ extern "C" {
 #endif
 
 typedef void* cactus_model_t;
+typedef void* cactus_index_t;
+typedef void* cactus_stream_transcribe_t;
 
 typedef void (*cactus_token_callback)(const char* token, uint32_t token_id, void* user_data);
 
-CACTUS_FFI_EXPORT cactus_model_t cactus_init(const char* model_path, size_t context_size, const char* corpus_dir);
+CACTUS_FFI_EXPORT cactus_model_t cactus_init(
+    const char* model_path,
+    const char* corpus_dir,                 // optional: NULL if no RAG corpus
+    bool cache_index                        // false = always rebuild index, true = load cached if available
+);
+
+CACTUS_FFI_EXPORT void cactus_destroy(cactus_model_t model);
+CACTUS_FFI_EXPORT void cactus_reset(cactus_model_t model);
+CACTUS_FFI_EXPORT void cactus_stop(cactus_model_t model);
 
 CACTUS_FFI_EXPORT int cactus_complete(
     cactus_model_t model,
     const char* messages_json,
     char* response_buffer,
     size_t buffer_size,
-    const char* options_json,
-    const char* tools_json,
-    cactus_token_callback callback,
-    void* user_data
+    const char* options_json,               // optional
+    const char* tools_json,                 // optional
+    cactus_token_callback callback,         // optional
+    void* user_data                         // optional
 );
 
 CACTUS_FFI_EXPORT int cactus_tokenize(
@@ -53,45 +63,38 @@ CACTUS_FFI_EXPORT int cactus_score_window(
     size_t buffer_size
 );
 
-
 CACTUS_FFI_EXPORT int cactus_transcribe(
     cactus_model_t model,
-    const char* audio_file_path,
+    const char* audio_file_path,            // NULL if using pcm_buffer
     const char* prompt,
     char* response_buffer,
     size_t buffer_size,
-    const char* options_json,
-    cactus_token_callback callback,
-    void* user_data,
-    const uint8_t* pcm_buffer,
+    const char* options_json,               // optional
+    cactus_token_callback callback,         // optional
+    void* user_data,                        // optional
+    const uint8_t* pcm_buffer,              // NULL if using audio_file_path
     size_t pcm_buffer_size
 );
 
-typedef void* cactus_stream_transcribe_t;
-
-CACTUS_FFI_EXPORT cactus_stream_transcribe_t cactus_stream_transcribe_init(cactus_model_t model);
-
-CACTUS_FFI_EXPORT int cactus_stream_transcribe_insert(
-    cactus_stream_transcribe_t stream,
-    const uint8_t* pcm_buffer,
-    size_t pcm_buffer_size
+CACTUS_FFI_EXPORT cactus_stream_transcribe_t cactus_stream_transcribe_start(
+    cactus_model_t model,
+    const char* options_json                // optional
 );
 
 CACTUS_FFI_EXPORT int cactus_stream_transcribe_process(
     cactus_stream_transcribe_t stream,
+    const uint8_t* pcm_buffer,
+    size_t pcm_buffer_size,
     char* response_buffer,
-    size_t buffer_size,
-    const char* options_json
+    size_t buffer_size
 );
 
-CACTUS_FFI_EXPORT int cactus_stream_transcribe_finalize(
+CACTUS_FFI_EXPORT int cactus_stream_transcribe_stop(
     cactus_stream_transcribe_t stream,
     char* response_buffer,
     size_t buffer_size
 );
 
-CACTUS_FFI_EXPORT void cactus_stream_transcribe_destroy(cactus_stream_transcribe_t stream);
-
 CACTUS_FFI_EXPORT int cactus_embed(
     cactus_model_t model,
     const char* text,
@@ -117,19 +120,24 @@ CACTUS_FFI_EXPORT int cactus_audio_embed(
     size_t* embedding_dim
 );
 
-CACTUS_FFI_EXPORT void cactus_reset(cactus_model_t model);
-
-CACTUS_FFI_EXPORT void cactus_stop(cactus_model_t model);
-
-CACTUS_FFI_EXPORT void cactus_destroy(cactus_model_t model);
-
-CACTUS_FFI_EXPORT const char* cactus_get_last_error(void);
-
-CACTUS_FFI_EXPORT void cactus_set_telemetry_token(const char* token);
+CACTUS_FFI_EXPORT int cactus_vad(
+    cactus_model_t model,
+    const char* audio_file_path,
+    char* response_buffer,
+    size_t buffer_size,
+    const char* options_json,
+    const uint8_t* pcm_buffer,
+    size_t pcm_buffer_size
+);
 
-CACTUS_FFI_EXPORT void cactus_set_pro_key(const char* pro_key);
+CACTUS_FFI_EXPORT int cactus_rag_query(
+    cactus_model_t model,
+    const char* query,
+    char* response_buffer,
+    size_t buffer_size,
+    size_t top_k
+);
 
-typedef void* cactus_index_t;
 
 CACTUS_FFI_EXPORT cactus_index_t cactus_index_init(
     const char* index_dir,
@@ -140,7 +148,7 @@ CACTUS_FFI_EXPORT int cactus_index_add(
     cactus_index_t index,
     const int* ids,
     const char** documents,
-    const char** metadatas,
+    const char** metadatas,                 // optional: can be NULL
     const float** embeddings,
     size_t count,
     size_t embedding_dim
@@ -169,7 +177,7 @@ CACTUS_FFI_EXPORT int cactus_index_query(
     const float** embeddings,
     size_t embeddings_count,
     size_t embedding_dim,
-    const char* options_json,
+    const char* options_json,               // optional
     int** id_buffers,
     size_t* id_buffer_sizes,
     float** score_buffers,
@@ -177,11 +185,14 @@ CACTUS_FFI_EXPORT int cactus_index_query(
 );
 
 CACTUS_FFI_EXPORT int cactus_index_compact(cactus_index_t index);
-
 CACTUS_FFI_EXPORT void cactus_index_destroy(cactus_index_t index);
 
+CACTUS_FFI_EXPORT const char* cactus_get_last_error(void);
+
+CACTUS_FFI_EXPORT void cactus_set_telemetry_environment(const char* framework, const char* cache_location);
+
 #ifdef __cplusplus
 }
 #endif
 
-#endif 
+#endif // CACTUS_FFI_H

package/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/cactus.h

@@ -7,7 +7,6 @@
 #include "engine/engine.h"
 #include "models/model.h"
 #include "ffi/cactus_ffi.h"
-#include "ffi/cactus_telemetry.h"
 #include "npu/npu.h"
 
 #endif // CACTUS_H