cactus-react-native 1.0.1 → 1.1.0

package/android/src/main/java/com/margelo/nitro/cactus/HybridCactusCrypto.kt

@@ -7,23 +7,32 @@ import java.util.Locale
 import java.util.UUID
 
 class HybridCactusCrypto : HybridCactusCryptoSpec() {
-  override fun uuidv5(namespaceUuid: String, name: String): Promise<String> {
-    return Promise.async {
-      val nsUuid = try {
-        UUID.fromString(namespaceUuid)
-      } catch (e: IllegalArgumentException) {
-        throw IllegalArgumentException("Invalid namespace UUID")
-      }
+  override fun uuidv5(
+    namespaceUuid: String,
+    name: String,
+  ): Promise<String> =
+    Promise.async {
+      val nsUuid =
+        try {
+          UUID.fromString(namespaceUuid)
+        } catch (e: IllegalArgumentException) {
+          throw IllegalArgumentException("Invalid namespace UUID")
+        }
 
-      val nsBytes = ByteBuffer.allocate(16).apply {
-        putLong(nsUuid.mostSignificantBits)
-        putLong(nsUuid.leastSignificantBits)
-      }.array()
+      val nsBytes =
+        ByteBuffer
+          .allocate(16)
+          .apply {
+            putLong(nsUuid.mostSignificantBits)
+            putLong(nsUuid.leastSignificantBits)
+          }.array()
       val nameBytes = name.toByteArray(Charsets.UTF_8)
 
-      val sha1 = MessageDigest.getInstance("SHA-1")
-        .apply { update(nsBytes) }
-        .digest(nameBytes)
+      val sha1 =
+        MessageDigest
+          .getInstance("SHA-1")
+          .apply { update(nsBytes) }
+          .digest(nameBytes)
       val uuidBytes = sha1.copyOfRange(0, 16)
       uuidBytes[6] = (uuidBytes[6].toInt() and 0x0F or 0x50).toByte()
       uuidBytes[8] = (uuidBytes[8].toInt() and 0x3F or 0x80).toByte()
@@ -34,5 +43,4 @@ class HybridCactusCrypto : HybridCactusCryptoSpec() {
 
       uuid.toString().lowercase(Locale.ROOT)
     }
-  }
 }

package/android/src/main/java/com/margelo/nitro/cactus/HybridCactusDeviceInfo.kt

@@ -8,17 +8,20 @@ import com.margelo.nitro.core.Promise
 class HybridCactusDeviceInfo : HybridCactusDeviceInfoSpec() {
   private val context = NitroModules.applicationContext ?: error("Android context not found")
 
-  override fun getAppIdentifier(): Promise<String?> {
-    return Promise.async { context.packageName }
-  }
+  override fun getAppIdentifier(): Promise<String?> = Promise.async { context.packageName }
 
-  override fun getDeviceInfo(): Promise<DeviceInfo> {
-    return Promise.async {
+  override fun getDeviceInfo(): Promise<DeviceInfo> =
+    Promise.async {
       DeviceInfo(
-        brand = Build.MANUFACTURER, model = Build.MODEL, device_id = Settings.Secure.getString(
-          context.contentResolver, Settings.Secure.ANDROID_ID
-        ), os = "Android", os_version = Build.VERSION.RELEASE
+        brand = Build.MANUFACTURER,
+        model = Build.MODEL,
+        device_id =
+          Settings.Secure.getString(
+            context.contentResolver,
+            Settings.Secure.ANDROID_ID,
+          ),
+        os = "Android",
+        os_version = Build.VERSION.RELEASE,
       )
     }
-  }
 }

package/android/src/main/java/com/margelo/nitro/cactus/HybridCactusFileSystem.kt

@@ -16,29 +16,28 @@ import kotlin.math.floor
 class HybridCactusFileSystem : HybridCactusFileSystemSpec() {
   private val context = NitroModules.applicationContext ?: error("Android context not found")
 
-  override fun getCactusDirectory(): Promise<String> {
-    return Promise.async { cactusFile().absolutePath }
-  }
+  override fun getCactusDirectory(): Promise<String> = Promise.async { cactusFile().absolutePath }
 
-  override fun fileExists(path: String): Promise<Boolean> {
-    return Promise.async {
+  override fun fileExists(path: String): Promise<Boolean> =
+    Promise.async {
       val cactusDir = cactusFile()
       val file = File(cactusDir, path)
       file.exists()
     }
-  }
 
-  override fun writeFile(path: String, content: String): Promise<Unit> {
-    return Promise.async {
+  override fun writeFile(
+    path: String,
+    content: String,
+  ): Promise<Unit> =
+    Promise.async {
       val cactusDir = cactusFile()
       val file = File(cactusDir, path)
       file.parentFile?.mkdirs()
       file.writeText(content)
     }
-  }
 
-  override fun readFile(path: String): Promise<String> {
-    return Promise.async {
+  override fun readFile(path: String): Promise<String> =
+    Promise.async {
       val cactusDir = cactusFile()
       val file = File(cactusDir, path)
 
@@ -48,10 +47,9 @@ class HybridCactusFileSystem : HybridCactusFileSystemSpec() {
 
       file.readText()
     }
-  }
 
-  override fun deleteFile(path: String): Promise<Unit> {
-    return Promise.async {
+  override fun deleteFile(path: String): Promise<Unit> =
+    Promise.async {
       val cactusDir = cactusFile()
       val file = File(cactusDir, path)
 
@@ -61,18 +59,15 @@ class HybridCactusFileSystem : HybridCactusFileSystemSpec() {
 
       file.deleteRecursively()
     }
-  }
 
-  override fun modelExists(model: String): Promise<Boolean> {
-    return Promise.async { modelFile(model).exists() }
-  }
+  override fun modelExists(model: String): Promise<Boolean> = Promise.async { modelFile(model).exists() }
 
-  override fun getModelPath(model: String): Promise<String> {
-    return Promise.async { modelFile(model).absolutePath }
-  }
+  override fun getModelPath(model: String): Promise<String> = Promise.async { modelFile(model).absolutePath }
 
   override fun downloadModel(
-    model: String, from: String, callback: ((progress: Double) -> Unit)?
+    model: String,
+    from: String,
+    callback: ((progress: Double) -> Unit)?,
   ): Promise<Unit> {
     return Promise.async {
       val modelFile = modelFile(model)
@@ -82,21 +77,23 @@ class HybridCactusFileSystem : HybridCactusFileSystemSpec() {
         return@async
       }
 
-      val url = try {
-        URL(from)
-      } catch (_: Throwable) {
-        throw Error("Invalid URL")
-      }
+      val url =
+        try {
+          URL(from)
+        } catch (_: Throwable) {
+          throw Error("Invalid URL")
+        }
 
       val tmpZip = File.createTempFile("dl_", ".zip", context.cacheDir)
       var connection: HttpURLConnection? = null
 
       try {
-        connection = (url.openConnection() as HttpURLConnection).apply {
-          connectTimeout = 30_000
-          readTimeout = 5 * 60_000
-          instanceFollowRedirects = true
-        }
+        connection =
+          (url.openConnection() as HttpURLConnection).apply {
+            connectTimeout = 30_000
+            readTimeout = 5 * 60_000
+            instanceFollowRedirects = true
+          }
         connection.connect()
         val code = connection.responseCode
 
@@ -129,11 +126,13 @@ class HybridCactusFileSystem : HybridCactusFileSystemSpec() {
 
                   if (contentLength > 0) {
                     // cap at 0.99; 1.0 will be sent after unzip
-                    val pct = floor(
-                      (downloaded.toDouble() / contentLength.toDouble()).coerceIn(
-                        0.0, 1.0
-                      ) * 99
-                    ) / 100.0
+                    val pct =
+                      floor(
+                        (downloaded.toDouble() / contentLength.toDouble()).coerceIn(
+                          0.0,
+                          1.0,
+                        ) * 99,
+                      ) / 100.0
 
                     if (pct - lastPct >= 0.01) {
                       callback?.invoke(pct)
@@ -160,7 +159,10 @@ class HybridCactusFileSystem : HybridCactusFileSystemSpec() {
     }
   }
 
-  private fun unzipItem(zipFile: File, outDir: File) {
+  private fun unzipItem(
+    zipFile: File,
+    outDir: File,
+  ) {
     val outRoot = outDir.canonicalFile
     ZipInputStream(BufferedInputStream(FileInputStream(zipFile))).use { zis ->
       var entry: ZipEntry? = zis.nextEntry
@@ -196,8 +198,8 @@ class HybridCactusFileSystem : HybridCactusFileSystemSpec() {
     }
   }
 
-  override fun deleteModel(model: String): Promise<Unit> {
-    return Promise.async {
+  override fun deleteModel(model: String): Promise<Unit> =
+    Promise.async {
       val modelFile = modelFile(model)
 
       if (!modelFile.exists()) {
@@ -206,7 +208,6 @@ class HybridCactusFileSystem : HybridCactusFileSystemSpec() {
 
       modelFile.deleteRecursively()
     }
-  }
 
   private fun cactusFile(): File {
     val documentsDir =

package/android/src/main/java/com/margelo/nitro/cactus/HybridCactusImage.kt

@@ -0,0 +1,81 @@
+package com.margelo.nitro.cactus
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import androidx.core.graphics.createBitmap
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.Promise
+import java.io.File
+import java.io.FileOutputStream
+import java.util.UUID
+
+class HybridCactusImage : HybridCactusImageSpec() {
+  private val context = NitroModules.applicationContext ?: error("Android context not found")
+
+  override fun base64(path: String): Promise<String> =
+    Promise.async {
+      val file = File(path)
+
+      if (!file.exists()) {
+        throw Error("No such file: $path")
+      }
+
+      val imageData = file.readBytes()
+      android.util.Base64.encodeToString(imageData, android.util.Base64.NO_WRAP)
+    }
+
+  override fun resize(
+    path: String,
+    height: Double,
+    width: Double,
+    quality: Double,
+  ): Promise<String> =
+    Promise.async {
+      val file = File(path)
+
+      if (!file.exists()) {
+        throw Error("No such file: $path")
+      }
+
+      val bitmap = BitmapFactory.decodeFile(path)
+      if (bitmap == null) {
+        throw Error("Failed to load image from: $path")
+      }
+      val resizedBitmap = createBitmap(width.toInt(), height.toInt(), Bitmap.Config.RGB_565)
+      val canvas = android.graphics.Canvas(resizedBitmap)
+      val paint =
+        android.graphics.Paint().apply {
+          isFilterBitmap = true
+          isAntiAlias = true
+        }
+
+      val scaleX = width.toFloat() / bitmap.width
+      val scaleY = height.toFloat() / bitmap.height
+      val matrix =
+        android.graphics.Matrix().apply {
+          setScale(scaleX, scaleY)
+        }
+
+      canvas.drawBitmap(bitmap, matrix, paint)
+      bitmap.recycle()
+
+      val cacheDir = context.cacheDir
+      val outputDir = File(cacheDir, "cactus/images")
+      outputDir.mkdirs()
+
+      val fileName = "${UUID.randomUUID()}.jpg"
+      val outputFile = File(outputDir, fileName)
+
+      try {
+        FileOutputStream(outputFile).use { outputStream ->
+          val qualityInt = (quality * 100).toInt().coerceIn(0, 100)
+          resizedBitmap.compress(Bitmap.CompressFormat.JPEG, qualityInt, outputStream)
+        }
+        resizedBitmap.recycle()
+        outputFile.absolutePath
+      } catch (e: Exception) {
+        resizedBitmap.recycle()
+        throw Error("Failed to save resized image: ${e.message}")
+      }
+    }
+}

package/cpp/HybridCactus.cpp

@@ -1,30 +1,41 @@
 #include "HybridCactus.hpp"
 
-namespace margelo::nitro::cactus
-{
+namespace margelo::nitro::cactus {
 HybridCactus::HybridCactus() : HybridObject(TAG) {}
 
-std::shared_ptr<Promise<void>> HybridCactus::init(const std::string &modelPath, double contextSize) {
-  return Promise<void>::async([this, modelPath, contextSize]() -> void {
-    std::lock_guard<std::mutex> lock(this->_modelMutex);
+std::shared_ptr<Promise<void>>
+HybridCactus::init(const std::string &modelPath, double contextSize,
+                   const std::optional<std::string> &corpusDir) {
+  return Promise<void>::async(
+      [this, modelPath, contextSize, corpusDir]() -> void {
+        std::lock_guard<std::mutex> lock(this->_modelMutex);
 
-    if (this->_model) {
-      throw std::runtime_error("Cactus model is already initialized");
-    }
+        if (this->_model) {
+          throw std::runtime_error("Cactus model is already initialized");
+        }
 
-    const cactus_model_t model = cactus_init(modelPath.c_str(), contextSize);
+        const cactus_model_t model =
+            cactus_init(modelPath.c_str(), contextSize,
+                        corpusDir ? corpusDir->c_str() : nullptr);
 
-    if (!model) {
-      throw std::runtime_error("Failed to initialize Cactus model");
-    }
+        if (!model) {
+          throw std::runtime_error("Failed to initialize Cactus model");
+        }
 
-    this->_model = model;
-    this->_contextSize = contextSize;
-  });
+        this->_model = model;
+        this->_contextSize = contextSize;
+      });
 }
 
-std::shared_ptr<Promise<std::string>> HybridCactus::complete(const std::string &messagesJson, double responseBufferSize, const std::optional<std::string> &optionsJson, const std::optional<std::string> &toolsJson, const std::optional<std::function<void(const std::string & /* token */, double /* tokenId */)>> &callback) {
-  return Promise<std::string>::async([this, messagesJson, optionsJson, toolsJson, callback, responseBufferSize]() -> std::string {
+std::shared_ptr<Promise<std::string>> HybridCactus::complete(
+    const std::string &messagesJson, double responseBufferSize,
+    const std::optional<std::string> &optionsJson,
+    const std::optional<std::string> &toolsJson,
+    const std::optional<std::function<void(const std::string & /* token */,
+                                           double /* tokenId */)>> &callback) {
+  return Promise<std::string>::async([this, messagesJson, optionsJson,
+                                      toolsJson, callback,
+                                      responseBufferSize]() -> std::string {
     std::lock_guard<std::mutex> lock(this->_modelMutex);
 
     if (!this->_model) {
@@ -32,28 +43,26 @@ std::shared_ptr<Promise<std::string>> HybridCactus::complete(const std::string &
     }
 
     struct CallbackCtx {
-      const std::function<void(const std::string & /* token */, double /* tokenId */)> *callback;
-    } callbackCtx{ callback.has_value() ? &callback.value() : nullptr };
-
-    auto cactusTokenCallback = [](const char* token, uint32_t tokenId, void* userData) {
-      auto* callbackCtx = static_cast<CallbackCtx*>(userData);
-      if (!callbackCtx || !callbackCtx->callback || !(*callbackCtx->callback)) return;
+      const std::function<void(const std::string & /* token */,
+                               double /* tokenId */)> *callback;
+    } callbackCtx{callback.has_value() ? &callback.value() : nullptr};
+
+    auto cactusTokenCallback = [](const char *token, uint32_t tokenId,
+                                  void *userData) {
+      auto *callbackCtx = static_cast<CallbackCtx *>(userData);
+      if (!callbackCtx || !callbackCtx->callback || !(*callbackCtx->callback))
+        return;
       (*callbackCtx->callback)(token, tokenId);
     };
 
     std::string responseBuffer;
     responseBuffer.resize(responseBufferSize);
 
-    int result = cactus_complete(
-                    this->_model,
-                    messagesJson.c_str(),
-                    responseBuffer.data(),
-                    responseBufferSize,
-                    optionsJson ? optionsJson->c_str() : nullptr,
-                    toolsJson ? toolsJson->c_str() : nullptr,
-                    cactusTokenCallback,
-                    &callbackCtx
-                    );
+    int result = cactus_complete(this->_model, messagesJson.c_str(),
+                                 responseBuffer.data(), responseBufferSize,
+                                 optionsJson ? optionsJson->c_str() : nullptr,
+                                 toolsJson ? toolsJson->c_str() : nullptr,
+                                 cactusTokenCallback, &callbackCtx);
 
     if (result < 0) {
       throw std::runtime_error("Cactus completion failed");
@@ -66,29 +75,139 @@ std::shared_ptr<Promise<std::string>> HybridCactus::complete(const std::string &
   });
 }
 
-std::shared_ptr<Promise<std::vector<double>>> HybridCactus::embed(const std::string &text, double embeddingBufferSize) {
-  return Promise<std::vector<double>>::async([this, text, embeddingBufferSize]() -> std::vector<double> {
+std::shared_ptr<Promise<std::string>> HybridCactus::transcribe(
+    const std::string &audioFilePath, const std::string &prompt,
+    double responseBufferSize, const std::optional<std::string> &optionsJson,
+    const std::optional<std::function<void(const std::string & /* token */,
+                                           double /* tokenId */)>> &callback) {
+  return Promise<std::string>::async([this, audioFilePath, prompt, optionsJson,
+                                      callback,
+                                      responseBufferSize]() -> std::string {
     std::lock_guard<std::mutex> lock(this->_modelMutex);
 
     if (!this->_model) {
       throw std::runtime_error("Cactus model is not initialized");
     }
 
-    std::vector<float> embeddingBuffer(embeddingBufferSize);
-    size_t embeddingDim;
+    struct CallbackCtx {
+      const std::function<void(const std::string & /* token */,
+                               double /* tokenId */)> *callback;
+    } callbackCtx{callback.has_value() ? &callback.value() : nullptr};
+
+    auto cactusTokenCallback = [](const char *token, uint32_t tokenId,
+                                  void *userData) {
+      auto *callbackCtx = static_cast<CallbackCtx *>(userData);
+      if (!callbackCtx || !callbackCtx->callback || !(*callbackCtx->callback))
+        return;
+      (*callbackCtx->callback)(token, tokenId);
+    };
+
+    std::string responseBuffer;
+    responseBuffer.resize(responseBufferSize);
 
-    int result = cactus_embed(this->_model, text.c_str(), embeddingBuffer.data(), embeddingBufferSize * sizeof(float), &embeddingDim);
+    int result =
+        cactus_transcribe(this->_model, audioFilePath.c_str(), prompt.c_str(),
+                          responseBuffer.data(), responseBufferSize,
+                          optionsJson ? optionsJson->c_str() : nullptr,
+                          cactusTokenCallback, &callbackCtx);
 
     if (result < 0) {
-      throw std::runtime_error("Cactus embedding failed");
+      throw std::runtime_error("Cactus transcription failed");
     }
 
-    embeddingBuffer.resize(embeddingDim);
+    // Remove null terminator
+    responseBuffer.resize(strlen(responseBuffer.c_str()));
 
-    return std::vector<double>(embeddingBuffer.begin(), embeddingBuffer.end());
+    return responseBuffer;
   });
 }
 
+std::shared_ptr<Promise<std::vector<double>>>
+HybridCactus::embed(const std::string &text, double embeddingBufferSize) {
+  return Promise<std::vector<double>>::async(
+      [this, text, embeddingBufferSize]() -> std::vector<double> {
+        std::lock_guard<std::mutex> lock(this->_modelMutex);
+
+        if (!this->_model) {
+          throw std::runtime_error("Cactus model is not initialized");
+        }
+
+        std::vector<float> embeddingBuffer(embeddingBufferSize);
+        size_t embeddingDim;
+
+        int result =
+            cactus_embed(this->_model, text.c_str(), embeddingBuffer.data(),
+                         embeddingBufferSize * sizeof(float), &embeddingDim);
+
+        if (result < 0) {
+          throw std::runtime_error("Cactus embedding failed");
+        }
+
+        embeddingBuffer.resize(embeddingDim);
+
+        return std::vector<double>(embeddingBuffer.begin(),
+                                   embeddingBuffer.end());
+      });
+}
+
+std::shared_ptr<Promise<std::vector<double>>>
+HybridCactus::imageEmbed(const std::string &imagePath,
+                         double embeddingBufferSize) {
+  return Promise<std::vector<double>>::async(
+      [this, imagePath, embeddingBufferSize]() -> std::vector<double> {
+        std::lock_guard<std::mutex> lock(this->_modelMutex);
+
+        if (!this->_model) {
+          throw std::runtime_error("Cactus model is not initialized");
+        }
+
+        std::vector<float> embeddingBuffer(embeddingBufferSize);
+        size_t embeddingDim;
+
+        int result = cactus_image_embed(
+            this->_model, imagePath.c_str(), embeddingBuffer.data(),
+            embeddingBufferSize * sizeof(float), &embeddingDim);
+
+        if (result < 0) {
+          throw std::runtime_error("Cactus image embedding failed");
+        }
+
+        embeddingBuffer.resize(embeddingDim);
+
+        return std::vector<double>(embeddingBuffer.begin(),
+                                   embeddingBuffer.end());
+      });
+}
+
+std::shared_ptr<Promise<std::vector<double>>>
+HybridCactus::audioEmbed(const std::string &audioPath,
+                         double embeddingBufferSize) {
+  return Promise<std::vector<double>>::async(
+      [this, audioPath, embeddingBufferSize]() -> std::vector<double> {
+        std::lock_guard<std::mutex> lock(this->_modelMutex);
+
+        if (!this->_model) {
+          throw std::runtime_error("Cactus model is not initialized");
+        }
+
+        std::vector<float> embeddingBuffer(embeddingBufferSize);
+        size_t embeddingDim;
+
+        int result = cactus_audio_embed(
+            this->_model, audioPath.c_str(), embeddingBuffer.data(),
+            embeddingBufferSize * sizeof(float), &embeddingDim);
+
+        if (result < 0) {
+          throw std::runtime_error("Cactus audio embedding failed");
+        }
+
+        embeddingBuffer.resize(embeddingDim);
+
+        return std::vector<double>(embeddingBuffer.begin(),
+                                   embeddingBuffer.end());
+      });
+}
+
 std::shared_ptr<Promise<void>> HybridCactus::reset() {
   return Promise<void>::async([this]() -> void {
     std::lock_guard<std::mutex> lock(this->_modelMutex);
@@ -102,9 +221,7 @@ std::shared_ptr<Promise<void>> HybridCactus::reset() {
 }
 
 std::shared_ptr<Promise<void>> HybridCactus::stop() {
-  return Promise<void>::async([this]() -> void {
-    cactus_stop(this->_model);
-  });
+  return Promise<void>::async([this]() -> void { cactus_stop(this->_model); });
 }
 
 std::shared_ptr<Promise<void>> HybridCactus::destroy() {

package/cpp/HybridCactus.hpp

@@ -5,26 +5,46 @@
 
 #include <mutex>
 
-namespace margelo::nitro::cactus
-{
+namespace margelo::nitro::cactus {
 
-class HybridCactus : public HybridCactusSpec
-{
+class HybridCactus : public HybridCactusSpec {
 public:
   HybridCactus();
-  
-  std::shared_ptr<Promise<void>> init(const std::string &modelPath, double contextSize) override;
-  
-  std::shared_ptr<Promise<std::string>> complete(const std::string &messagesJson, double responseBufferSize, const std::optional<std::string> &optionsJson, const std::optional<std::string> &toolsJson, const std::optional<std::function<void(const std::string & /* token */, double /* tokenId */)>> &callback) override;
-  
-  std::shared_ptr<Promise<std::vector<double>>> embed(const std::string &text, double embeddingBufferSize) override;
-  
+
+  std::shared_ptr<Promise<void>>
+  init(const std::string &modelPath, double contextSize,
+       const std::optional<std::string> &corpusDir) override;
+
+  std::shared_ptr<Promise<std::string>> complete(
+      const std::string &messagesJson, double responseBufferSize,
+      const std::optional<std::string> &optionsJson,
+      const std::optional<std::string> &toolsJson,
+      const std::optional<std::function<void(const std::string & /* token */,
+                                             double /* tokenId */)>> &callback)
+      override;
+
+  std::shared_ptr<Promise<std::string>> transcribe(
+      const std::string &audioFilePath, const std::string &prompt,
+      double responseBufferSize, const std::optional<std::string> &optionsJson,
+      const std::optional<std::function<void(const std::string & /* token */,
+                                             double /* tokenId */)>> &callback)
+      override;
+
+  std::shared_ptr<Promise<std::vector<double>>>
+  embed(const std::string &text, double embeddingBufferSize) override;
+
+  std::shared_ptr<Promise<std::vector<double>>>
+  imageEmbed(const std::string &imagePath, double embeddingBufferSize) override;
+
+  std::shared_ptr<Promise<std::vector<double>>>
+  audioEmbed(const std::string &audioPath, double embeddingBufferSize) override;
+
   std::shared_ptr<Promise<void>> reset() override;
-  
+
   std::shared_ptr<Promise<void>> stop() override;
-  
+
   std::shared_ptr<Promise<void>> destroy() override;
-  
+
 private:
   cactus_model_t _model = nullptr;
   size_t _contextSize;