cactus-react-native 1.7.0 → 1.10.0

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

@@ -2,6 +2,7 @@
 #define CACTUS_UTILS_H
 
 #include "../engine/engine.h"
+#include "../models/model.h"
 #include <string>
 #include <vector>
 #include <unordered_map>
@@ -12,6 +13,9 @@
 #include <iostream>
 #include <filesystem>
 #include <cctype>
+#include <algorithm>
+#include <cmath>
+#include <limits>
 #include <memory>
 #include <atomic>
 #include <mutex>
@@ -101,12 +105,92 @@ inline cactus::engine::AudioProcessor::SpectrogramConfig get_whisper_spectrogram
     return cfg;
 }
 
+inline cactus::engine::AudioProcessor::SpectrogramConfig get_parakeet_spectrogram_config() {
+    cactus::engine::AudioProcessor::SpectrogramConfig cfg{};
+    cfg.n_fft        = 512;
+    cfg.frame_length = 400;
+    cfg.hop_length   = 160;
+    cfg.power        = 2.0f;
+    cfg.center       = true;
+    cfg.pad_mode     = "constant";
+    cfg.onesided     = true;
+    cfg.dither       = 0.0f;
+    cfg.mel_floor    = 5.960464477539063e-08f; // 2^-24 guard value used by HF Parakeet.
+    cfg.log_mel      = "log";
+    cfg.reference    = 1.0f;
+    cfg.min_value    = 1e-10f;
+    cfg.remove_dc_offset = false;
+    cfg.hann_periodic = false;
+    return cfg;
+}
+
+inline void apply_preemphasis(std::vector<float>& waveform, float coefficient = 0.97f) {
+    if (waveform.size() < 2 || coefficient == 0.0f) {
+        return;
+    }
+    for (size_t i = waveform.size() - 1; i > 0; --i) {
+        waveform[i] -= coefficient * waveform[i - 1];
+    }
+}
+
+inline void normalize_parakeet_log_mel(std::vector<float>& mel, size_t num_mels, float epsilon = 1e-5f) {
+    if (mel.empty() || num_mels == 0 || (mel.size() % num_mels) != 0) {
+        return;
+    }
+    const size_t num_frames = mel.size() / num_mels;
+    if (num_frames == 0) {
+        return;
+    }
+
+    for (size_t m = 0; m < num_mels; ++m) {
+        const size_t base = m * num_frames;
+        float mean = 0.0f;
+        for (size_t t = 0; t < num_frames; ++t) {
+            mean += mel[base + t];
+        }
+        mean /= static_cast<float>(num_frames);
+
+        float variance = 0.0f;
+        for (size_t t = 0; t < num_frames; ++t) {
+            const float d = mel[base + t] - mean;
+            variance += d * d;
+        }
+        const float denom = static_cast<float>(std::max<size_t>(1, num_frames - 1));
+        const float inv_std = 1.0f / std::sqrt((variance / denom) + epsilon);
+        for (size_t t = 0; t < num_frames; ++t) {
+            mel[base + t] = (mel[base + t] - mean) * inv_std;
+        }
+    }
+}
+
+inline void trim_mel_frames(std::vector<float>& mel, size_t num_mels, size_t valid_frames) {
+    if (mel.empty() || num_mels == 0 || (mel.size() % num_mels) != 0) {
+        return;
+    }
+    size_t total_frames = mel.size() / num_mels;
+    if (valid_frames == 0 || valid_frames >= total_frames) {
+        return;
+    }
+    std::vector<float> trimmed(num_mels * valid_frames);
+    for (size_t m = 0; m < num_mels; ++m) {
+        const float* src = &mel[m * total_frames];
+        float* dst = &trimmed[m * valid_frames];
+        std::copy(src, src + valid_frames, dst);
+    }
+    mel.swap(trimmed);
+}
+
 } // namespace audio
 } // namespace cactus
 
 namespace cactus {
 namespace ffi {
 
+inline bool env_flag_enabled(const char* key) {
+    const char* value = std::getenv(key);
+    return value && value[0] != '\0' && !(value[0] == '0' && value[1] == '\0');
+}
+
 inline std::string generateUUID() {
 #ifdef __APPLE__
     uuid_t uuid;
@@ -114,6 +198,25 @@ inline std::string generateUUID() {
     char uuid_str[37];
     uuid_unparse_lower(uuid, uuid_str);
     return std::string(uuid_str);
+#else
+    static std::random_device rd;
+    static std::mt19937 gen(rd());
+    static std::uniform_int_distribution<> dis(0, 15);
+    static std::uniform_int_distribution<> dis2(8, 11);
+
+    std::stringstream ss;
+    ss << std::hex;
+    for (int i = 0; i < 8; i++) ss << dis(gen);
+    ss << "-";
+    for (int i = 0; i < 4; i++) ss << dis(gen);
+    ss << "-4";
+    for (int i = 0; i < 3; i++) ss << dis(gen);
+    ss << "-";
+    ss << dis2(gen);
+    for (int i = 0; i < 3; i++) ss << dis(gen);
+    ss << "-";
+    for (int i = 0; i < 12; i++) ss << dis(gen);
+    return ss.str();
 #endif
 }
 
@@ -150,6 +253,130 @@ inline std::string escape_json_string(const std::string& s) {
     return o.str();
 }
 
+
+inline std::string trim_string(const std::string& s) {
+    size_t start = 0;
+    while (start < s.size() && std::isspace(static_cast<unsigned char>(s[start]))) ++start;
+    size_t end = s.size();
+    while (end > start && std::isspace(static_cast<unsigned char>(s[end - 1]))) --end;
+    return s.substr(start, end - start);
+}
+
+inline std::string env_or_default(const char* key, const char* fallback) {
+    const char* v = std::getenv(key);
+    if (v && v[0] != '\0') return std::string(v);
+    return std::string(fallback);
+}
+
+inline std::string json_string_field(const std::string& json, const std::string& key) {
+    std::string pattern = "\"" + key + "\":";
+    size_t pos = json.find(pattern);
+    if (pos == std::string::npos) return {};
+
+    size_t i = pos + pattern.size();
+    while (i < json.size() && std::isspace(static_cast<unsigned char>(json[i]))) i++;
+    if (i >= json.size() || json[i] != '"') return {};
+    ++i;
+
+    std::string out;
+    out.reserve(128);
+    while (i < json.size()) {
+        char c = json[i++];
+        if (c == '"') return out;
+        if (c == '\\' && i < json.size()) {
+            char e = json[i++];
+            switch (e) {
+                case '"':  out.push_back('"');  break;
+                case '\\': out.push_back('\\'); break;
+                case '/':  out.push_back('/');  break;
+                case 'b':  out.push_back('\b'); break;
+                case 'f':  out.push_back('\f'); break;
+                case 'n':  out.push_back('\n'); break;
+                case 'r':  out.push_back('\r'); break;
+                case 't':  out.push_back('\t'); break;
+                default:   out.push_back(e);    break;
+            }
+            continue;
+        }
+        out.push_back(c);
+    }
+    return {};
+}
+
+inline std::string json_array_field(const std::string& json, const std::string& key) {
+    std::string pattern = "\"" + key + "\":";
+    size_t pos = json.find(pattern);
+    if (pos == std::string::npos) return "[]";
+    size_t start = pos + pattern.size();
+    while (start < json.size() && std::isspace(static_cast<unsigned char>(json[start]))) ++start;
+    if (start >= json.size() || json[start] != '[') return "[]";
+
+    int depth = 1;
+    size_t end = start + 1;
+    while (end < json.size() && depth > 0) {
+        if (json[end] == '[') depth++;
+        else if (json[end] == ']') depth--;
+        end++;
+    }
+    return json.substr(start, end - start);
+}
+
+inline std::vector<std::string> split_json_array(const std::string& array_json) {
+    std::vector<std::string> out;
+    if (array_json.size() < 2 || array_json.front() != '[' || array_json.back() != ']') return out;
+
+    size_t i = 1;
+    while (i + 1 < array_json.size()) {
+        while (i + 1 < array_json.size() &&
+               (std::isspace(static_cast<unsigned char>(array_json[i])) || array_json[i] == ',')) i++;
+        if (i + 1 >= array_json.size() || array_json[i] != '{') break;
+
+        size_t start = i;
+        int depth = 0;
+        bool in_str = false;
+        bool esc = false;
+        for (; i < array_json.size(); ++i) {
+            char c = array_json[i];
+            if (in_str) {
+                if (esc) esc = false;
+                else if (c == '\\') esc = true;
+                else if (c == '"') in_str = false;
+                continue;
+            }
+            if (c == '"') { in_str = true; continue; }
+            if (c == '{') depth++;
+            if (c == '}') {
+                depth--;
+                if (depth == 0) {
+                    out.push_back(array_json.substr(start, i - start + 1));
+                    i++;
+                    break;
+                }
+            }
+        }
+    }
+    return out;
+}
+
+inline std::string serialize_tools_json(const std::vector<ToolFunction>& tools) {
+    if (tools.empty()) return "";
+    std::ostringstream oss;
+    oss << "[";
+    for (size_t i = 0; i < tools.size(); ++i) {
+        if (i > 0) oss << ",";
+        oss << "{\"type\":\"function\",\"function\":{";
+        oss << "\"name\":\"" << escape_json_string(tools[i].name) << "\",";
+        oss << "\"description\":\"" << escape_json_string(tools[i].description) << "\"";
+        auto it = tools[i].parameters.find("schema");
+        if (it != tools[i].parameters.end()) {
+            oss << ",\"parameters\":" << it->second;
+        }
+        oss << "}}";
+    }
+    oss << "]";
+    return oss.str();
+}
+
 inline void handle_error_response(const std::string& error_message, char* response_buffer, size_t buffer_size) {
     std::ostringstream json;
     json << "{";
@@ -324,7 +551,10 @@ inline void parse_options_json(const std::string& json,
                                float& confidence_threshold,
                                bool& include_stop_sequences,
                                bool& use_vad,
-                               bool& telemetry_enabled) {
+                               bool& telemetry_enabled,
+                               bool* auto_handoff = nullptr,
+                               size_t* cloud_timeout_ms = nullptr,
+                               bool* handoff_with_images = nullptr) {
     temperature = 0.0f;
     top_p = 0.0f;
     top_k = 0;
@@ -335,6 +565,9 @@ inline void parse_options_json(const std::string& json,
     include_stop_sequences = false;
     use_vad = true;
     telemetry_enabled = true;
+    if (auto_handoff) *auto_handoff = true;
+    if (cloud_timeout_ms) *cloud_timeout_ms = 15000;
+    if (handoff_with_images) *handoff_with_images = true;
     stop_sequences.clear();
 
     if (json.empty()) return;
@@ -403,6 +636,32 @@ inline void parse_options_json(const std::string& json,
         telemetry_enabled = (json.substr(pos, 4) == "true");
     }
 
+    if (auto_handoff) {
+        pos = json.find("\"auto_handoff\"");
+        if (pos != std::string::npos) {
+            pos = json.find(':', pos) + 1;
+            while (pos < json.length() && std::isspace(json[pos])) pos++;
+            *auto_handoff = (json.substr(pos, 4) == "true");
+        }
+    }
+
+    if (cloud_timeout_ms) {
+        pos = json.find("\"cloud_timeout_ms\"");
+        if (pos != std::string::npos) {
+            pos = json.find(':', pos) + 1;
+            *cloud_timeout_ms = std::stoul(json.substr(pos));
+        }
+    }
+
+    if (handoff_with_images) {
+        pos = json.find("\"handoff_with_images\"");
+        if (pos != std::string::npos) {
+            pos = json.find(':', pos) + 1;
+            while (pos < json.length() && std::isspace(json[pos])) pos++;
+            *handoff_with_images = (json.substr(pos, 4) == "true");
+        }
+    }
+
     pos = json.find("\"stop_sequences\"");
     if (pos != std::string::npos) {
         pos = json.find('[', pos);
@@ -422,31 +681,8 @@ inline void parse_options_json(const std::string& json,
     }
 }
 
-inline std::string format_tools_for_prompt(const std::vector<ToolFunction>& tools) {
-    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";
-        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 += ",\"parameters\":" + tools[i].parameters.at("schema");
-        }
-        formatted_tools_json += "}}";
-    }
-    return formatted_tools_json;
-}
-
 static inline std::string trim_lfm2_slice(const std::string& value, size_t begin, size_t end) {
-    while (begin < end && std::isspace(static_cast<unsigned char>(value[begin]))) {
-        begin++;
-    }
-    while (end > begin && std::isspace(static_cast<unsigned char>(value[end - 1]))) {
-        end--;
-    }
-    return value.substr(begin, end - begin);
+    return trim_string(value.substr(begin, end - begin));
 }
 
 static inline void append_lfm2_call(const std::string& entry,
@@ -577,23 +813,49 @@ inline void parse_function_calls_from_response(const std::string& response_text,
 
             if (!content.empty() && content.front() == '[' && content.back() == ']') {
                 std::string inner = content.substr(1, content.size() - 2);
-                size_t start = 0;
-                int paren_depth = 0;
-
-                for (size_t i = 0; i < inner.size(); ++i) {
-                    char c = inner[i];
-                    if (c == '(') {
-                        paren_depth++;
-                    } else if (c == ')' && paren_depth > 0) {
-                        paren_depth--;
-                    } else if (c == ',' && paren_depth == 0) {
-                        append_lfm2_call(inner.substr(start, i - start), function_calls);
-                        start = i + 1;
+
+                size_t inner_first = inner.find_first_not_of(" \t\n\r");
+                if (inner_first != std::string::npos && inner[inner_first] == '{') {
+                    size_t pos = inner_first;
+                    while (pos < inner.size()) {
+                        if (inner[pos] == '{') {
+                            int brace_depth = 1;
+                            size_t obj_start = pos;
+                            pos++;
+                            while (pos < inner.size() && brace_depth > 0) {
+                                if (inner[pos] == '{') brace_depth++;
+                                else if (inner[pos] == '}') brace_depth--;
+                                pos++;
+                            }
+                            if (brace_depth == 0) {
+                                std::string json_obj = inner.substr(obj_start, pos - obj_start);
+                                if (json_obj.find("\"name\"") != std::string::npos) {
+                                    function_calls.push_back(json_obj);
+                                }
+                            }
+                        } else {
+                            pos++;
+                        }
+                    }
+                } else {
+                    size_t start = 0;
+                    int paren_depth = 0;
+
+                    for (size_t i = 0; i < inner.size(); ++i) {
+                        char c = inner[i];
+                        if (c == '(') {
+                            paren_depth++;
+                        } else if (c == ')' && paren_depth > 0) {
+                            paren_depth--;
+                        } else if (c == ',' && paren_depth == 0) {
+                            append_lfm2_call(inner.substr(start, i - start), function_calls);
+                            start = i + 1;
+                        }
                     }
-                }
 
-                if (start < inner.size()) {
-                    append_lfm2_call(inner.substr(start), function_calls);
+                    if (start < inner.size()) {
+                        append_lfm2_call(inner.substr(start), function_calls);
+                    }
                 }
             } else if (!content.empty()) {
                 append_lfm2_call(content, function_calls);
@@ -648,7 +910,7 @@ inline std::string construct_response_json(const std::string& regular_response,
                                            bool cloud_handoff = false) {
     std::ostringstream json;
     json << "{";
-    json << "\"success\":" << (cloud_handoff ? "false" : "true") << ",";
+    json << "\"success\":true,";
     json << "\"error\":null,";
     json << "\"cloud_handoff\":" << (cloud_handoff ? "true" : "false") << ",";
     json << "\"response\":\"" << escape_json_string(regular_response) << "\",";
@@ -671,30 +933,6 @@ inline std::string construct_response_json(const std::string& regular_response,
     return json.str();
 }
 
-inline std::string construct_cloud_handoff_json(float confidence,
-                                                 double time_to_first_token,
-                                                 double prefill_tps,
-                                                 size_t prompt_tokens) {
-    std::ostringstream json;
-    json << "{";
-    json << "\"success\":false,";
-    json << "\"error\":null,";
-    json << "\"cloud_handoff\":true,";
-    json << "\"response\":null,";
-    json << "\"function_calls\":[],";
-    json << "\"confidence\":" << std::fixed << std::setprecision(4) << confidence << ",";
-    json << "\"time_to_first_token_ms\":" << std::fixed << std::setprecision(2) << time_to_first_token << ",";
-    json << "\"total_time_ms\":" << std::fixed << std::setprecision(2) << time_to_first_token << ",";
-    json << "\"prefill_tps\":" << std::fixed << std::setprecision(2) << prefill_tps << ",";
-    json << "\"decode_tps\":0.0,";
-    json << "\"ram_usage_mb\":" << std::fixed << std::setprecision(2) << get_ram_usage_mb() << ",";
-    json << "\"prefill_tokens\":" << prompt_tokens << ",";
-    json << "\"decode_tokens\":0,";
-    json << "\"total_tokens\":" << prompt_tokens;
-    json << "}";
-    return json.str();
-}
-
 inline std::string serialize_function_calls(const std::vector<std::string>& calls) {
     if (calls.empty()) return "[]";
     std::ostringstream oss;
@@ -720,4 +958,4 @@ const char* cactus_get_last_error();
 }
 #endif
 
-#endif // CACTUS_UTILS_H
+#endif // CACTUS_UTILS_H

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

@@ -56,6 +56,12 @@ struct Config {
     uint32_t num_shared_experts = 0;
     uint32_t num_top_experts = 0;
     uint32_t moe_every_n_layers = 0;
+    uint32_t moe_intermediate_dim = 0;
+    uint32_t num_dense_layers = 0;
+    uint32_t num_experts_per_tok = 0;
+    bool norm_topk_prob = false;
+    bool use_expert_bias = false;
+    float routed_scaling_factor = 1.0f;
     bool tie_word_embeddings = true;
 
     uint32_t vision_hidden_dim = 0;
@@ -93,8 +99,22 @@ struct Config {
     uint32_t num_encoder_layers = 0;
     uint32_t num_decoder_layers = 0;
     float partial_rotary_factor = 0.0f;
-
-    enum class ModelType {QWEN = 0, GEMMA = 1, NOMIC = 3, LFM2 = 5, SIGLIP2 = 6, WHISPER = 7, MOONSHINE = 8, SILERO_VAD = 9};
+    uint32_t pad_token_id = 0;
+    uint32_t conv_kernel_size = 0;
+    uint32_t subsampling_conv_kernel_size = 0;
+    uint32_t subsampling_conv_stride = 0;
+    uint32_t subsampling_conv_channels = 0;
+    uint32_t subsampling_factor = 0;
+    uint32_t num_mel_bins = 80;
+    std::string encoder_hidden_act = "silu";
+    uint32_t predictor_hidden_dim = 0;
+    uint32_t predictor_num_layers = 0;
+    uint32_t tdt_joint_dim = 0;
+    uint32_t tdt_num_durations = 0;
+    uint32_t tdt_blank_id = 0;
+    std::vector<uint32_t> tdt_durations;
+
+    enum class ModelType {QWEN = 0, GEMMA = 1, NOMIC = 3, LFM2 = 5, SIGLIP2 = 6, WHISPER = 7, MOONSHINE = 8, SILERO_VAD = 9, PARAKEET = 10, PARAKEET_TDT = 11};
     ModelType model_type = ModelType::QWEN;
 
     enum class ModelVariant {DEFAULT = 0, VLM = 1, EXTRACT = 2, RAG = 3};
@@ -168,7 +188,7 @@ public:
     uint32_t get_global_img_token_id() const { return global_img_token_id_; }
 
 protected:
-    enum class ModelType { UNKNOWN, QWEN, GEMMA, LFM2, BERT, WHISPER};
+    enum class ModelType { UNKNOWN, QWEN, GEMMA, LFM2, BERT, WHISPER, PARAKEET};
     ModelType model_type_ = ModelType::UNKNOWN;
     enum class ModelVariant { DEFAULT, VLM, EXTRACT, RAG};
     ModelVariant model_variant_ = ModelVariant::DEFAULT;
@@ -366,7 +386,6 @@ struct KVCache {
                          size_t num_tokens, size_t kv_heads, size_t head_dim);
 
     bool is_empty() const { return current_seq_len == 0; }
-    bool is_int8() const { return precision == Precision::INT8; }
     void* get_key_ptr(size_t layer);
     void* get_value_ptr(size_t layer);
 
@@ -684,6 +703,8 @@ public:
         float reference = 1.0f;
         float min_value = 1e-10f;
         bool remove_dc_offset = false;
+        float preemphasis = 0.0f;
+        bool hann_periodic = true;
     };
 
     AudioProcessor();
@@ -696,6 +717,11 @@ public:
         const std::vector<float>& waveform,
         const SpectrogramConfig& config);
 
+    static std::vector<float> compute_irfft(
+        const std::vector<float>& complex_input,
+        size_t n,
+        const char* norm = "backward");
+
     const std::vector<float>& get_mel_filters() const { return mel_filters_; }
 
     size_t get_num_mel_filters() const { return num_mel_filters_; }
@@ -721,6 +747,8 @@ namespace index {
     struct QueryResult {
         int doc_id;
         float score;
+
+        QueryResult(int doc_id, float score) : doc_id(doc_id), score(score) {}
     };
 
     struct QueryOptions {