cactus-react-native 1.2.1 → 1.4.0

package/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/{ffi_utils.h → cactus_utils.h}

@@ -1,5 +1,5 @@
-#ifndef CACTUS_FFI_UTILS_H
-#define CACTUS_FFI_UTILS_H
+#ifndef CACTUS_UTILS_H
+#define CACTUS_UTILS_H
 
 #include "../engine/engine.h"
 #include <string>
@@ -12,10 +12,51 @@
 #include <iostream>
 #include <filesystem>
 #include <cctype>
+#include <memory>
+#include <atomic>
+#include <mutex>
+#include <random>
+
+#ifdef __APPLE__
+#include <uuid/uuid.h>
+#endif
+
+struct CactusModelHandle {
+    std::unique_ptr<cactus::engine::Model> model;
+    std::atomic<bool> should_stop;
+    std::vector<uint32_t> processed_tokens;
+    std::mutex model_mutex;
+    std::string model_name;
+
+    CactusModelHandle() : should_stop(false) {}
+};
+
+extern std::string last_error_message;
+
+bool matches_stop_sequence(const std::vector<uint32_t>& generated_tokens,
+                           const std::vector<std::vector<uint32_t>>& stop_sequences);
 
 namespace cactus {
 namespace ffi {
 
+#ifndef CACTUS_VERSION
+#define CACTUS_VERSION "unknown"
+#endif
+
+inline const char* getVersion() {
+    return CACTUS_VERSION;
+}
+
+inline std::string generateUUID() {
+#ifdef __APPLE__
+    uuid_t uuid;
+    uuid_generate_random(uuid);
+    char uuid_str[37];
+    uuid_unparse_lower(uuid, uuid_str);
+    return std::string(uuid_str);
+#endif
+}
+
 struct ToolFunction {
     std::string name;
     std::string description;
@@ -175,49 +216,58 @@ inline std::vector<ToolFunction> parse_tools_json(const std::string& json) {
     return tools;
 }
 
-inline void parse_options_json(const std::string& json, 
-                               float& temperature, float& top_p, 
+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) {
+                               std::vector<std::string>& stop_sequences,
+                               bool& force_tools) {
     temperature = 0.0f;
-    top_p = 0.0f;       
-    top_k = 0;           
-    max_tokens = 100;    
+    top_p = 0.0f;
+    top_k = 0;
+    max_tokens = 100;
+    force_tools = false;
     stop_sequences.clear();
-    
+
     if (json.empty()) return;
-    
+
     size_t pos = json.find("\"temperature\"");
     if (pos != std::string::npos) {
         pos = json.find(':', pos) + 1;
         temperature = std::stof(json.substr(pos));
     }
-    
+
     pos = json.find("\"top_p\"");
     if (pos != std::string::npos) {
         pos = json.find(':', pos) + 1;
         top_p = std::stof(json.substr(pos));
     }
-    
+
     pos = json.find("\"top_k\"");
     if (pos != std::string::npos) {
         pos = json.find(':', pos) + 1;
         top_k = std::stoul(json.substr(pos));
     }
-    
+
     pos = json.find("\"max_tokens\"");
     if (pos != std::string::npos) {
         pos = json.find(':', pos) + 1;
         max_tokens = std::stoul(json.substr(pos));
     }
-    
+
+    pos = json.find("\"force_tools\"");
+    if (pos != std::string::npos) {
+        pos = json.find(':', pos) + 1;
+        while (pos < json.length() && std::isspace(json[pos])) pos++;
+        force_tools = (json.substr(pos, 4) == "true");
+    }
+
     pos = json.find("\"stop_sequences\"");
     if (pos != std::string::npos) {
         pos = json.find('[', pos);
         if (pos != std::string::npos) {
             size_t end_pos = json.find(']', pos);
             size_t seq_pos = json.find('"', pos);
-            
+
             while (seq_pos != std::string::npos && seq_pos < end_pos) {
                 size_t seq_start = seq_pos + 1;
                 size_t seq_end = json.find('"', seq_start);
@@ -234,7 +284,7 @@ inline std::string format_tools_for_prompt(const std::vector<ToolFunction>& tool
     if (tools.empty()) return "";
     std::string formatted_tools_json;
     for (size_t i = 0; i < tools.size(); i++) {
-        if (i > 0) formatted_tools_json += ",\n";
+        if (i > 0) formatted_tools_json += "\n";
         formatted_tools_json += "{\"type\":\"function\",\"function\":{\"name\":\""
                               + tools[i].name
                               + "\",\"description\":\""
@@ -398,4 +448,41 @@ inline std::string construct_response_json(const std::string& regular_response,
 } // namespace ffi
 } // namespace cactus
 
-#endif // CACTUS_FFI_UTILS_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+const char* cactus_get_last_error();
+
+__attribute__((weak))
+const char* register_app(const char* encrypted_data);
+
+__attribute__((weak))
+const char* get_device_id(const char* current_token);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+
+__attribute__((weak))
+inline const char* register_app(const char* encrypted_data) {
+    (void)encrypted_data;
+    static thread_local std::string uuid_storage;
+    uuid_storage = cactus::ffi::generateUUID();
+    return uuid_storage.c_str();
+}
+
+__attribute__((weak))
+inline const char* get_device_id(const char* current_token) {
+    (void)current_token;
+    static thread_local std::string uuid_storage;
+    uuid_storage = cactus::ffi::generateUUID();
+    return uuid_storage.c_str();
+}
+}
+#endif
+
+#endif // CACTUS_UTILS_H

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

@@ -3,6 +3,7 @@
 #include <vector>
 #include <string>
 #include <unordered_map>
+#include <unordered_set>
 #include <memory>
 #include <cstdint>
 
@@ -32,6 +33,9 @@ extern "C" {
 class CactusGraph;
 
 namespace cactus {
+namespace npu {
+    class NPUPrefill;
+}
 namespace engine {
 
 class Siglip2Preprocessor;
@@ -349,6 +353,13 @@ struct KVCache {
     void update_from_graph(CactusGraph* gb, const std::vector<size_t>& k_nodes,
                           const std::vector<size_t>& v_nodes, size_t seq_len,
                           size_t num_layers, size_t kv_heads, size_t head_dim);
+
+    // Update KV cache from NPU prefill outputs
+    // NPU outputs are in shape [num_tokens, num_kv_heads, head_dim]
+    // This handles transposition to cache format and sliding window
+    void update_from_npu(size_t layer_idx, const __fp16* k_data, const __fp16* v_data,
+                         size_t num_tokens, size_t kv_heads, size_t head_dim);
+
     bool is_empty() const { return current_seq_len == 0; }
     void* get_key_ptr(size_t layer);
     void* get_value_ptr(size_t layer);
@@ -365,6 +376,85 @@ struct KVCache {
     CircularView get_value_view(size_t layer);
 };
 
+class ToolCallConstrainer {
+public:
+    enum class State {
+        START,                  // -> expect {
+        EXPECT_FC_KEY,          // -> expect "function_call"
+        EXPECT_FC_COLON,        // -> expect :
+        EXPECT_FC_OPEN_BRACE,   // -> expect {
+        EXPECT_NAME_KEY,        // -> expect "name"
+        EXPECT_NAME_COLON,      // -> expect :
+        EXPECT_NAME_VALUE,      // -> expect "<function_name>"
+        EXPECT_COMMA,           // -> expect ,
+        EXPECT_ARGS_KEY,        // -> expect "arguments"
+        EXPECT_ARGS_COLON,      // -> expect :
+        IN_ARGUMENTS,           // -> free JSON, track brace depth
+        EXPECT_INNER_CLOSE,     // -> expect } to close inner object
+        EXPECT_OUTER_CLOSE,     // -> expect } to close outer object
+        DONE,                   // complete
+
+        LFM_START,              // -> expect <|tool_call_start|>
+        LFM_EXPECT_BRACKET,     // -> expect [
+        LFM_IN_FUNC_NAME,       // -> expect function name
+        LFM_EXPECT_PAREN,       // -> expect (
+        LFM_IN_ARGUMENTS,       // -> arguments until )
+        LFM_EXPECT_BRACKET_CLOSE, // -> expect ]
+        LFM_EXPECT_END          // -> expect <|tool_call_end|>
+    };
+
+    void init(Config::ModelType model_type,
+              const std::vector<std::string>& function_names,
+              Tokenizer* tokenizer);
+
+    const std::unordered_map<uint32_t, float>& get_bias() const { return current_bias_; }
+
+    void update(uint32_t token_id, const std::string& decoded_text);
+
+    void reset();
+
+    bool is_active() const { return active_; }
+
+private:
+    bool active_ = false;
+    State state_ = State::START;
+    Config::ModelType model_type_ = Config::ModelType::QWEN;
+    Tokenizer* tokenizer_ = nullptr;
+
+    std::vector<std::string> function_names_;
+    std::string generated_text_;
+    int brace_depth_ = 0;  // Track nested braces in arguments
+
+    // Pre-tokenized token sets for each grammar element
+    std::unordered_set<uint32_t> open_brace_tokens_;      // {
+    std::unordered_set<uint32_t> close_brace_tokens_;     // }
+    std::unordered_set<uint32_t> colon_tokens_;           // :
+    std::unordered_set<uint32_t> comma_tokens_;           // ,
+    std::unordered_set<uint32_t> fc_key_tokens_;          // "function_call"
+    std::unordered_set<uint32_t> name_key_tokens_;        // "name"
+    std::unordered_set<uint32_t> args_key_tokens_;        // "arguments"
+    std::unordered_set<uint32_t> quote_tokens_;           // "
+    std::unordered_set<uint32_t> backtick_tokens_;        // ` (to block markdown code fences)
+    std::unordered_set<uint32_t> response_starter_tokens_; // Common response starters to block (I, I'm, Sorry, etc.)
+    std::unordered_set<uint32_t> all_func_name_tokens_;   // All function name tokens combined
+    std::unordered_map<std::string, std::vector<uint32_t>> func_name_sequences_;  // Full token sequence per function
+
+    // LFM2-specific tokens
+    std::unordered_set<uint32_t> tool_start_tokens_;
+    std::unordered_set<uint32_t> tool_end_tokens_;
+    std::unordered_set<uint32_t> bracket_open_tokens_;    // [
+    std::unordered_set<uint32_t> bracket_close_tokens_;   // ]
+    std::unordered_set<uint32_t> paren_open_tokens_;      // (
+    std::unordered_set<uint32_t> paren_close_tokens_;     // )
+    std::unordered_set<uint32_t> equals_tokens_;          // =
+
+    std::unordered_map<uint32_t, float> current_bias_;
+
+    void compute_bias();
+    void tokenize_grammar_elements();
+    void add_tokens_for_string(const std::string& str, std::unordered_set<uint32_t>& token_set);
+};
+
 class Model {
 public:
     struct DebugNode {
@@ -386,26 +476,40 @@ public:
     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 = "", bool prefill_only = false);
+    virtual uint32_t decode(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 void prefill(const std::vector<uint32_t>& tokens, size_t chunk_size = 256, const std::string& profile_file = "");
 
-    virtual uint32_t generate_with_images(const std::vector<uint32_t>& tokens, const std::vector<std::string>& image_paths,
+    virtual uint32_t decode_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,
+
+    virtual uint32_t decode_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 = "");
+    std::vector<float> get_embeddings(const std::vector<uint32_t>& tokens, bool pooled = true, bool normalize = false, 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(); }
-    
+
+    double score_tokens_window_logprob(const std::vector<uint32_t>& tokens, size_t start, size_t end, size_t context, size_t* tokens_scored);
+
+
+
     void set_cache_window(size_t window_size, size_t sink_size = 4) { kv_cache_.set_window_size(window_size, sink_size); }
 
+    bool load_npu_prefill(const std::string& model_path);
+    bool has_npu_prefill() const;
+    size_t get_prefill_chunk_size() const;
+
+    void set_tool_constraints(const std::vector<std::string>& function_names);
+    void clear_tool_constraints();
+    void update_tool_constraints(uint32_t token_id);
+
     void* graph_handle_;
 
 protected:
@@ -449,6 +553,12 @@ protected:
     bool init_internal(CactusGraph* gb, const std::string& model_folder, size_t context_size,
                        const std::string& system_prompt, bool do_warmup);
     bool owns_graph_;
+
+    std::unique_ptr<npu::NPUPrefill> npu_prefill_;
+    void prefill_npu(const std::vector<uint32_t>& tokens);
+    virtual std::vector<__fp16> get_token_embeddings(const std::vector<uint32_t>& tokens);
+
+    ToolCallConstrainer tool_constrainer_;
 };
 
 std::unique_ptr<Model> create_model(const std::string& model_folder);

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

@@ -8,6 +8,88 @@
 #include <cstring>
 #include <stdexcept>
 #include <string>
+#include <mutex>
+#include <sstream>
+#include <iostream>
+
+namespace cactus {
+
+enum class LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3,
+    NONE = 4
+};
+
+class Logger {
+public:
+    static Logger& instance() {
+        static Logger logger;
+        return logger;
+    }
+
+    void set_level(LogLevel level) { min_level_ = level; }
+    LogLevel get_level() const { return min_level_; }
+
+    void set_callback(std::function<void(LogLevel, const std::string&, const std::string&)> cb) {
+        std::lock_guard<std::mutex> lock(mutex_);
+        callback_ = cb;
+    }
+
+    void log(LogLevel level, const std::string& component, const std::string& message) {
+        if (level < min_level_) return;
+
+        std::lock_guard<std::mutex> lock(mutex_);
+
+        if (callback_) {
+            callback_(level, component, message);
+        } else {
+            std::cerr << "[" << level_string(level) << "] [" << component << "] " << message << std::endl;
+        }
+
+        if (level == LogLevel::ERROR) {
+            last_error_ = "[" + component + "] " + message;
+        }
+    }
+
+    const std::string& last_error() const { return last_error_; }
+    void clear_error() { last_error_.clear(); }
+
+private:
+    Logger() : min_level_(LogLevel::WARN) {}
+
+    static const char* level_string(LogLevel level) {
+        switch (level) {
+            case LogLevel::DEBUG: return "DEBUG";
+            case LogLevel::INFO:  return "INFO";
+            case LogLevel::WARN:  return "WARN";
+            case LogLevel::ERROR: return "ERROR";
+            default: return "?";
+        }
+    }
+
+    LogLevel min_level_;
+    std::mutex mutex_;
+    std::string last_error_;
+    std::function<void(LogLevel, const std::string&, const std::string&)> callback_;
+};
+
+} // namespace cactus
+
+#define CACTUS_LOG(level, component, msg) \
+    do { \
+        if (static_cast<int>(level) >= static_cast<int>(cactus::Logger::instance().get_level())) { \
+            std::ostringstream _cactus_log_ss; \
+            _cactus_log_ss << msg; \
+            cactus::Logger::instance().log(level, component, _cactus_log_ss.str()); \
+        } \
+    } while(0)
+
+#define CACTUS_LOG_DEBUG(component, msg) CACTUS_LOG(cactus::LogLevel::DEBUG, component, msg)
+#define CACTUS_LOG_INFO(component, msg)  CACTUS_LOG(cactus::LogLevel::INFO, component, msg)
+#define CACTUS_LOG_WARN(component, msg)  CACTUS_LOG(cactus::LogLevel::WARN, component, msg)
+#define CACTUS_LOG_ERROR(component, msg) CACTUS_LOG(cactus::LogLevel::ERROR, component, msg)
 
 namespace GraphFile {
     class MappedFile;
@@ -144,7 +226,7 @@ struct OpParams {
     size_t slice_start = 0;
     size_t slice_length = 0;
     size_t window_size = 0;
-    bool is_causal = true;  // Default to causal for backward compatibility
+    bool is_causal = true;  
     std::vector<size_t> new_shape;
     std::vector<size_t> permutation;
     Precision output_precision = Precision::INT8;
@@ -158,10 +240,13 @@ struct OpParams {
     size_t top_k = 0;
     size_t random_seed = 0;
     
-    size_t index_value = 0;  // For INDEX operation
-    size_t num_classes = 0;  // For scatter operations
+    size_t index_value = 0;  
+    size_t num_classes = 0; 
     size_t dst_height = 0;
-    size_t dst_width = 0;   
+    size_t dst_width = 0;
+
+    std::vector<float> bias_values;
+    std::vector<uint32_t> bias_indices;
 };
 
 struct GraphNode {
@@ -294,7 +379,8 @@ public:
     size_t conv1d_causal(size_t input, size_t weight, size_t kernel_size, size_t dilation = 1);
     size_t conv1d_k3(size_t input, size_t weight, size_t stride);
     
-    size_t sample(size_t logits, float temperature = 0.6f, float top_p = 0.95f, size_t top_k = 20);
+    size_t sample(size_t logits, float temperature = 0.6f, float top_p = 0.95f, size_t top_k = 20,
+                  const std::unordered_map<uint32_t, float>& logit_bias = {});
     
     size_t concat(size_t input1, size_t input2, int axis = 0);
     size_t scatter_topk(size_t indices, size_t values, size_t num_classes);

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

@@ -102,18 +102,23 @@ void cactus_matmul_f32(const float* a, const float* b_transposed, float* c,
                        size_t M, size_t K, size_t N);
 
 
-void cactus_transpose_2d_int8(const int8_t* source, int8_t* destination, 
+void cactus_transpose_2d_int8(const int8_t* source, int8_t* destination,
                                size_t num_rows, size_t num_cols, size_t start_row, size_t end_row);
-void cactus_transpose_2d_f32(const float* source, float* destination, 
+void cactus_transpose_2d_f16(const __fp16* source, __fp16* destination,
+                             size_t num_rows, size_t num_cols, size_t start_row, size_t end_row);
+void cactus_transpose_2d_f32(const float* source, float* destination,
                              size_t num_rows, size_t num_cols, size_t start_row, size_t end_row);
 
-void cactus_transpose_int8(const int8_t* source, int8_t* destination, const size_t* shape, 
+void cactus_transpose_int8(const int8_t* source, int8_t* destination, const size_t* shape,
                            const size_t* permutation, size_t ndim, size_t start_idx, size_t end_idx);
-void cactus_transpose_f32(const float* source, float* destination, const size_t* shape, 
+void cactus_transpose_f16(const __fp16* source, __fp16* destination, const size_t* shape,
+                          const size_t* permutation, size_t ndim, size_t start_idx, size_t end_idx);
+void cactus_transpose_f32(const float* source, float* destination, const size_t* shape,
                           const size_t* permutation, size_t ndim, size_t start_idx, size_t end_idx);
 
 int64_t cactus_sum_all_int8(const int8_t* data, size_t num_elements);
 void cactus_sum_axis_int8(const int8_t* input, int8_t* output, size_t outer_size, size_t axis_size, size_t inner_size);
+double cactus_sum_all_f16(const __fp16* data, size_t num_elements);
 double cactus_sum_all_f32(const float* data, size_t num_elements);
 void cactus_sum_axis_f32(const float* input, float* output, size_t outer_size, size_t axis_size, size_t inner_size);
 
@@ -278,9 +283,13 @@ void cactus_bilinear_interpolation_fp32(const float* input, float* output, size_
                                         size_t dst_height, size_t dst_width);
 
 void cactus_sample_f32(const float* logits, uint32_t* output, size_t vocab_size,
-                       float temperature, float top_p, size_t top_k, size_t random_seed);
+                       float temperature, float top_p, size_t top_k, size_t random_seed,
+                       const float* bias_values = nullptr, const uint32_t* bias_indices = nullptr,
+                       size_t bias_count = 0);
 void cactus_sample_f16(const __fp16* logits, uint32_t* output, size_t vocab_size,
-                       float temperature, float top_p, size_t top_k, size_t random_seed);
+                       float temperature, float top_p, size_t top_k, size_t random_seed,
+                       const float* bias_values = nullptr, const uint32_t* bias_indices = nullptr,
+                       size_t bias_count = 0);
 
 
 void cactus_concat_f32(const float* input1, const float* input2, float* output,

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

@@ -7,5 +7,7 @@
 #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

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

@@ -3,6 +3,7 @@
 
 #include <stddef.h>
 #include <stdint.h>
+#include <stdbool.h>
 
 #if __GNUC__ >= 4
   #define CACTUS_FFI_EXPORT __attribute__ ((visibility ("default")))
@@ -33,6 +34,26 @@ CACTUS_FFI_EXPORT int cactus_complete(
     void* user_data
 );
 
+CACTUS_FFI_EXPORT int cactus_tokenize(
+    cactus_model_t model,
+    const char* text,
+    uint32_t* token_buffer,
+    size_t token_buffer_len,
+    size_t* out_token_len
+);
+
+CACTUS_FFI_EXPORT int cactus_score_window(
+    cactus_model_t model,
+    const uint32_t* tokens,
+    size_t token_len,
+    size_t start,
+    size_t end,
+    size_t context,
+    char* response_buffer,
+    size_t buffer_size
+);
+
+
 CACTUS_FFI_EXPORT int cactus_transcribe(
     cactus_model_t model,
     const char* audio_file_path,
@@ -41,7 +62,9 @@ CACTUS_FFI_EXPORT int cactus_transcribe(
     size_t buffer_size,
     const char* options_json,
     cactus_token_callback callback,
-    void* user_data
+    void* user_data,
+    const uint8_t* pcm_buffer,
+    size_t pcm_buffer_size
 );
 
 
@@ -50,7 +73,8 @@ CACTUS_FFI_EXPORT int cactus_embed(
     const char* text,
     float* embeddings_buffer,
     size_t buffer_size,
-    size_t* embedding_dim
+    size_t* embedding_dim,
+    bool normalize
 );
 
 CACTUS_FFI_EXPORT int cactus_image_embed(
@@ -75,6 +99,63 @@ 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 void cactus_set_pro_key(const char* pro_key);
+
+typedef void* cactus_index_t;
+
+CACTUS_FFI_EXPORT cactus_index_t cactus_index_init(
+    const char* index_dir,
+    size_t embedding_dim
+);
+
+CACTUS_FFI_EXPORT int cactus_index_add(
+    cactus_index_t index,
+    const int* ids,
+    const char** documents,
+    const char** metadatas,
+    const float** embeddings,
+    size_t count,
+    size_t embedding_dim
+);
+
+CACTUS_FFI_EXPORT int cactus_index_delete(
+    cactus_index_t index,
+    const int* ids,
+    size_t ids_count
+);
+
+CACTUS_FFI_EXPORT int cactus_index_get(
+    cactus_index_t index,
+    const int* ids,
+    size_t ids_count,
+    char** document_buffers,
+    size_t* document_buffer_sizes,
+    char** metadata_buffers,
+    size_t* metadata_buffer_sizes,
+    float** embedding_buffers,
+    size_t* embedding_buffer_sizes
+);
+
+CACTUS_FFI_EXPORT int cactus_index_query(
+    cactus_index_t index,
+    const float** embeddings,
+    size_t embeddings_count,
+    size_t embedding_dim,
+    const char* options_json,
+    int** id_buffers,
+    size_t* id_buffer_sizes,
+    float** score_buffers,
+    size_t* score_buffer_sizes
+);
+
+CACTUS_FFI_EXPORT int cactus_index_compact(cactus_index_t index);
+
+CACTUS_FFI_EXPORT void cactus_index_destroy(cactus_index_t index);
+
 #ifdef __cplusplus
 }
 #endif