cactus-react-native 1.0.2 → 1.1.0

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

@@ -75,6 +75,53 @@ std::shared_ptr<Promise<std::string>> HybridCactus::complete(
   });
 }
 
+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");
+    }
+
+    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_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 transcription failed");
+    }
+
+    // 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) {
   return Promise<std::vector<double>>::async(
@@ -103,6 +150,64 @@ HybridCactus::embed(const std::string &text, double embeddingBufferSize) {
       });
 }
 
+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);

package/cpp/HybridCactus.hpp

@@ -23,9 +23,22 @@ public:
                                              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;

package/cpp/cactus_ffi.h

@@ -33,6 +33,17 @@ CACTUS_FFI_EXPORT int cactus_complete(
     void* user_data
 );
 
+CACTUS_FFI_EXPORT int cactus_transcribe(
+    cactus_model_t model,
+    const char* audio_file_path,
+    const char* prompt,
+    char* response_buffer,
+    size_t buffer_size,
+    const char* options_json,
+    cactus_token_callback callback,
+    void* user_data
+);
+
 
 CACTUS_FFI_EXPORT int cactus_embed(
     cactus_model_t model,
@@ -42,6 +53,22 @@ CACTUS_FFI_EXPORT int cactus_embed(
     size_t* embedding_dim
 );
 
+CACTUS_FFI_EXPORT int cactus_image_embed(
+    cactus_model_t model,
+    const char* image_path,
+    float* embeddings_buffer,
+    size_t buffer_size,
+    size_t* embedding_dim
+);
+
+CACTUS_FFI_EXPORT int cactus_audio_embed(
+    cactus_model_t model,
+    const char* audio_path,
+    float* embeddings_buffer,
+    size_t buffer_size,
+    size_t* embedding_dim
+);
+
 CACTUS_FFI_EXPORT void cactus_reset(cactus_model_t model);
 
 CACTUS_FFI_EXPORT void cactus_stop(cactus_model_t model);

package/ios/HybridCactusImage.swift

@@ -0,0 +1,53 @@
+import Foundation
+import NitroModules
+import UIKit
+
+class HybridCactusImage: HybridCactusImageSpec {
+  func base64(path: String) throws -> Promise<String> {
+    return Promise.async {
+      let fileURL = URL(fileURLWithPath: path)
+      
+      if !FileManager.default.fileExists(atPath: fileURL.path) {
+        throw RuntimeError.error(withMessage: "No such file: \(path)")
+      }
+      
+      let imageData = try Data(contentsOf: fileURL)
+      return imageData.base64EncodedString()
+    }
+  }
+  
+  func resize(path: String, height: Double, width: Double, quality: Double) throws -> Promise<String> {
+    return Promise.async {
+      let fileURL = URL(fileURLWithPath: path)
+      
+      if !FileManager.default.fileExists(atPath: fileURL.path) {
+        throw RuntimeError.error(withMessage: "No such file: \(path)")
+      }
+      
+      guard let imageData = try? Data(contentsOf: fileURL),
+            let image = UIImage(data: imageData) else {
+        throw RuntimeError.error(withMessage: "Failed to load image from: \(path)")
+      }
+      
+      let targetSize = CGSize(width: CGFloat(width), height: CGFloat(height))
+      let renderer = UIGraphicsImageRenderer(size: targetSize)
+      let resizedImage = renderer.image { context in
+        image.draw(in: CGRect(origin: .zero, size: targetSize))
+      }
+      
+      guard let jpegData = resizedImage.jpegData(compressionQuality: CGFloat(quality)) else {
+        throw RuntimeError.error(withMessage: "Failed to compress resized image")
+      }
+      
+      let cacheDir = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask)[0]
+      let fileName = "\(UUID().uuidString).jpg"
+      let outputURL = cacheDir.appendingPathComponent("cactus/images", isDirectory: true)
+        .appendingPathComponent(fileName)
+      
+      try FileManager.default.createDirectory(at: outputURL.deletingLastPathComponent(), withIntermediateDirectories: true)
+      try jpegData.write(to: outputURL)
+      
+      return outputURL.path
+    }
+  }
+}

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

@@ -33,6 +33,17 @@ CACTUS_FFI_EXPORT int cactus_complete(
     void* user_data
 );
 
+CACTUS_FFI_EXPORT int cactus_transcribe(
+    cactus_model_t model,
+    const char* audio_file_path,
+    const char* prompt,
+    char* response_buffer,
+    size_t buffer_size,
+    const char* options_json,
+    cactus_token_callback callback,
+    void* user_data
+);
+
 
 CACTUS_FFI_EXPORT int cactus_embed(
     cactus_model_t model,
@@ -42,6 +53,22 @@ CACTUS_FFI_EXPORT int cactus_embed(
     size_t* embedding_dim
 );
 
+CACTUS_FFI_EXPORT int cactus_image_embed(
+    cactus_model_t model,
+    const char* image_path,
+    float* embeddings_buffer,
+    size_t buffer_size,
+    size_t* embedding_dim
+);
+
+CACTUS_FFI_EXPORT int cactus_audio_embed(
+    cactus_model_t model,
+    const char* audio_path,
+    float* embeddings_buffer,
+    size_t buffer_size,
+    size_t* embedding_dim
+);
+
 CACTUS_FFI_EXPORT void cactus_reset(cactus_model_t model);
 
 CACTUS_FFI_EXPORT void cactus_stop(cactus_model_t model);

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

@@ -7,11 +7,28 @@
 #include <cstdint>
 
 #include "../graph/graph.h"
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wc99-extensions"
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#elif defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpedantic"
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
 extern "C" {
     #include "../../libs/stb/stb_image.h"
     #include "../../libs/stb/stb_image_resize2.h"
 }
 
+#ifdef __clang__
+#pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+
 class CactusGraph;
 
 namespace cactus {
@@ -68,7 +85,7 @@ struct Config {
     float max_pixels_tolerance = 2.0f;
     bool do_image_splitting = true;
 
-    enum class ModelType {QWEN = 0, GEMMA = 1, SMOL = 2, NOMIC = 3, LFM2 = 5, SIGLIP2 = 6};
+    enum class ModelType {QWEN = 0, GEMMA = 1, SMOL = 2, NOMIC = 3, LFM2 = 5, SIGLIP2 = 6, WHISPER = 7};
     ModelType model_type = ModelType::QWEN;
 
     enum class ModelVariant {DEFAULT = 0, VLM = 1, EXTRACT = 2, RAG = 3};
@@ -139,7 +156,7 @@ public:
     void set_corpus_dir(const std::string& dir) { corpus_dir_ = dir; }
 
 protected:
-    enum class ModelType { UNKNOWN, QWEN, GEMMA, LFM2, SMOL, BERT };
+    enum class ModelType { UNKNOWN, QWEN, GEMMA, LFM2, SMOL, BERT, WHISPER};
     ModelType model_type_ = ModelType::UNKNOWN;
     enum class ModelVariant { DEFAULT, VLM, EXTRACT, RAG};
     ModelVariant model_variant_ = ModelVariant::DEFAULT;
@@ -365,28 +382,43 @@ public:
     const std::vector<DebugNode>& get_debug_nodes() const;
 
     virtual bool init(const std::string& model_folder, size_t context_size, const std::string& system_prompt = "", bool do_warmup = true);
+    
     virtual bool init(CactusGraph* external_graph, const std::string& model_folder, size_t context_size,
               const std::string& system_prompt = "", bool do_warmup = true);
+
     virtual uint32_t generate(const std::vector<uint32_t>& tokens, float temperature = -1.0f, float top_p = -1.0f,
                       size_t top_k = 0, const std::string& profile_file = "");
 
     virtual uint32_t generate_with_images(const std::vector<uint32_t>& tokens, const std::vector<std::string>& image_paths,
                                           float temperature = -1.0f, float top_p = -1.0f,
                                           size_t top_k = 0, const std::string& profile_file = "");
+    
+    virtual uint32_t generate_with_audio(const std::vector<uint32_t>& tokens, const std::vector<float>& mel_bins, float temperature = 0.0f, float top_p = 0.0f,
+                      size_t top_k = 0, const std::string& profile_file = "");
 
     std::vector<float> get_embeddings(const std::vector<uint32_t>& tokens, bool pooled = true, const std::string& profile_file = "");
+    
+    virtual std::vector<float> get_image_embeddings(const std::string& image_path);
+    
+    virtual std::vector<float> get_audio_embeddings(const std::vector<float>& mel_bins);
 
     virtual void reset_cache() { kv_cache_.reset(); }
+    
     void set_cache_window(size_t window_size, size_t sink_size = 4) { kv_cache_.set_window_size(window_size, sink_size); }
 
     void* graph_handle_;
 
 protected:
     virtual size_t forward(const std::vector<uint32_t>& tokens, bool use_cache = false) = 0;
+    
+    virtual size_t forward(const std::vector<float>& mel_bins, const std::vector<uint32_t>& tokens, bool use_cache = false);
+    
     virtual void load_weights_to_graph(CactusGraph* gb) = 0;
+    
     virtual size_t build_attention(CactusGraph* gb, size_t normalized_input, uint32_t layer_idx,
                           ComputeBackend backend, bool use_cache = false, size_t position_offset = 0) = 0;
-    virtual size_t build_mlp(CactusGraph* gb, size_t normalized_h, uint32_t layer_idx,
+    
+                          virtual size_t build_mlp(CactusGraph* gb, size_t normalized_h, uint32_t layer_idx,
                     ComputeBackend backend) const = 0;
     virtual size_t build_transformer_block(CactusGraph* gb, size_t hidden, uint32_t layer_idx,
                                   ComputeBackend backend, bool use_cache = false, size_t position_offset = 0) = 0;

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

@@ -8,6 +8,8 @@
 #include <stdexcept>
 #include <sstream>
 #include <iomanip>
+#include <fstream>
+#include <iostream>
 #include <filesystem>
 #include <cctype>
 
@@ -177,8 +179,8 @@ inline void parse_options_json(const std::string& json,
                                float& temperature, float& top_p, 
                                size_t& top_k, size_t& max_tokens,
                                std::vector<std::string>& stop_sequences) {
-    temperature = -1.0f; 
-    top_p = -1.0f;       
+    temperature = 0.0f;
+    top_p = 0.0f;       
     top_k = 0;           
     max_tokens = 100;    
     stop_sequences.clear();
@@ -233,15 +235,14 @@ inline std::string format_tools_for_prompt(const std::vector<ToolFunction>& tool
     std::string formatted_tools_json;
     for (size_t i = 0; i < tools.size(); i++) {
         if (i > 0) formatted_tools_json += ",\n";
-        formatted_tools_json += "  {\n";
-        formatted_tools_json += "    \"type\": \"function\",\n";
-        formatted_tools_json += "    \"function\": {\n";
-        formatted_tools_json += "      \"name\": \"" + tools[i].name + "\",\n";
-        formatted_tools_json += "      \"description\": \"" + tools[i].description + "\"";
+        formatted_tools_json += "{\"type\":\"function\",\"function\":{\"name\":\""
+                              + tools[i].name
+                              + "\",\"description\":\""
+                              + tools[i].description + "\"";
         if (tools[i].parameters.find("schema") != tools[i].parameters.end()) {
-            formatted_tools_json += ",\n      \"parameters\": " + tools[i].parameters.at("schema");
+            formatted_tools_json += ",\"parameters\":" + tools[i].parameters.at("schema");
         }
-        formatted_tools_json += "\n    }\n  }";
+        formatted_tools_json += "}}";
     }
     return formatted_tools_json;
 }

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

@@ -32,7 +32,7 @@ enum class OpType {
     SUM, MEAN, VARIANCE, MIN, MAX,
     RMS_NORM, ROPE, SOFTMAX, ATTENTION, CONV1D_CAUSAL, CONV1D_K3,
     SCALAR_ADD, SCALAR_SUBTRACT, SCALAR_MULTIPLY, SCALAR_DIVIDE, SCALAR_EXP, SCALAR_SQRT, SCALAR_COS, SCALAR_SIN,
-    SILU, GELU,
+    SILU, GELU, GELU_ERF,
     SAMPLE, CONCAT,
     SCATTER_TOPK,
     TOPK, LAYERNORM,
@@ -219,6 +219,7 @@ public:
     
     size_t silu(size_t input);
     size_t gelu(size_t input);
+    size_t gelu_erf(size_t input);
     
     size_t matmul(size_t input1, size_t input2, bool pretransposed_rhs = false, ComputeBackend backend = ComputeBackend::CPU);
     size_t transpose(size_t input, ComputeBackend backend = ComputeBackend::CPU);
@@ -236,6 +237,7 @@ public:
     size_t gather(size_t embeddings, size_t indices);
     size_t mmap_embeddings(const std::string& filename);
     size_t mmap_weights(const std::string& filename);
+    size_t load_weights(const std::string& filename); 
     void set_quantization_scale(size_t node_id, float scale);
     size_t embedding(const std::string& filename, size_t indices);
     size_t embedding(size_t embedding_tensor, size_t indices);