cactus-react-native 1.4.0 → 1.7.0

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

@@ -19,14 +19,53 @@
 
 #ifdef __APPLE__
 #include <uuid/uuid.h>
+#include <mach/mach.h>
+#elif defined(_WIN32)
+#include <windows.h>
+#include <psapi.h>
+#elif defined(__linux__) || defined(__ANDROID__)
+#include <unistd.h>
 #endif
 
+inline size_t get_memory_footprint_bytes() {
+#ifdef __APPLE__
+    task_vm_info_data_t vm_info;
+    mach_msg_type_number_t count = TASK_VM_INFO_COUNT;
+    if (task_info(mach_task_self(), TASK_VM_INFO, (task_info_t)&vm_info, &count) == KERN_SUCCESS)
+        return vm_info.phys_footprint;
+
+#elif defined(_WIN32)
+    PROCESS_MEMORY_COUNTERS_EX pmc;
+    if (GetProcessMemoryInfo(GetCurrentProcess(), (PROCESS_MEMORY_COUNTERS*)&pmc, sizeof(pmc)))
+        return pmc.PrivateUsage;
+        
+#elif defined(__linux__) || defined(__ANDROID__)
+    std::ifstream statm("/proc/self/statm");
+    if (statm.is_open()) {
+        size_t size, resident;
+        statm >> size >> resident;
+        return resident * sysconf(_SC_PAGESIZE);
+    }
+#endif
+    return 0;
+}
+
+inline double get_ram_usage_mb() {
+    return get_memory_footprint_bytes() / (1024.0 * 1024.0);
+}
+
 struct CactusModelHandle {
     std::unique_ptr<cactus::engine::Model> model;
+    std::unique_ptr<cactus::engine::Model> vad_model;
     std::atomic<bool> should_stop;
     std::vector<uint32_t> processed_tokens;
     std::mutex model_mutex;
     std::string model_name;
+    std::unique_ptr<cactus::engine::index::Index> corpus_index;
+    std::string corpus_dir;
+    size_t corpus_embedding_dim = 0;
+    std::vector<std::vector<float>> tool_embeddings;
+    std::vector<std::string> tool_texts;
 
     CactusModelHandle() : should_stop(false) {}
 };
@@ -36,16 +75,37 @@ 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);
 
+std::string retrieve_rag_context(CactusModelHandle* handle, const std::string& query);
+
 namespace cactus {
-namespace ffi {
+namespace audio {
+
+static constexpr size_t WHISPER_TARGET_FRAMES = 3000;
+static constexpr int WHISPER_SAMPLE_RATE = 16000;
+
+inline cactus::engine::AudioProcessor::SpectrogramConfig get_whisper_spectrogram_config() {
+    cactus::engine::AudioProcessor::SpectrogramConfig cfg{};
+    cfg.n_fft        = 400;
+    cfg.frame_length = 400;
+    cfg.hop_length   = 160;
+    cfg.power        = 2.0f;
+    cfg.center       = true;
+    cfg.pad_mode     = "reflect";
+    cfg.onesided     = true;
+    cfg.dither       = 0.0f;
+    cfg.mel_floor    = 1e-10f;
+    cfg.log_mel      = "log10";
+    cfg.reference    = 1.0f;
+    cfg.min_value    = 1e-10f;
+    cfg.remove_dc_offset = true;
+    return cfg;
+}
 
-#ifndef CACTUS_VERSION
-#define CACTUS_VERSION "unknown"
-#endif
+} // namespace audio
+} // namespace cactus
 
-inline const char* getVersion() {
-    return CACTUS_VERSION;
-}
+namespace cactus {
+namespace ffi {
 
 inline std::string generateUUID() {
 #ifdef __APPLE__
@@ -63,13 +123,52 @@ struct ToolFunction {
     std::unordered_map<std::string, std::string> parameters;
 };
 
-inline void handle_error_response(const std::string& error_message, char* response_buffer, size_t buffer_size) {
-    std::string sanitized_msg = error_message;
-    for (auto& c : sanitized_msg) {
-        if (c == '"') c = '\'';
-        if (c == '\n') c = ' ';
+} // namespace ffi
+} // namespace cactus
+
+std::vector<cactus::ffi::ToolFunction> select_relevant_tools(
+    CactusModelHandle* handle,
+    const std::string& query,
+    const std::vector<cactus::ffi::ToolFunction>& all_tools,
+    size_t top_k);
+
+#include "gemma_tools.h"
+
+namespace cactus {
+namespace ffi {
+
+inline std::string escape_json_string(const std::string& s) {
+    std::ostringstream o;
+    for (char c : s) {
+        if (c == '"') o << "\\\"";
+        else if (c == '\n') o << "\\n";
+        else if (c == '\r') o << "\\r";
+        else if (c == '\t') o << "\\t";
+        else if (c == '\\') o << "\\\\";
+        else o << c;
     }
-    std::string error_json = "{\"success\":false,\"error\":\"" + sanitized_msg + "\"}";
+    return o.str();
+}
+
+inline void handle_error_response(const std::string& error_message, char* response_buffer, size_t buffer_size) {
+    std::ostringstream json;
+    json << "{";
+    json << "\"success\":false,";
+    json << "\"error\":\"" << escape_json_string(error_message) << "\",";
+    json << "\"cloud_handoff\":false,";
+    json << "\"response\":null,";
+    json << "\"function_calls\":[],";
+    json << "\"confidence\":0.0,";
+    json << "\"time_to_first_token_ms\":0.0,";
+    json << "\"total_time_ms\":0.0,";
+    json << "\"prefill_tps\":0.0,";
+    json << "\"decode_tps\":0.0,";
+    json << "\"ram_usage_mb\":" << std::fixed << std::setprecision(2) << get_ram_usage_mb() << ",";
+    json << "\"prefill_tokens\":0,";
+    json << "\"decode_tokens\":0,";
+    json << "\"total_tokens\":0";
+    json << "}";
+    std::string error_json = json.str();
     if (response_buffer && error_json.length() < buffer_size) {
         std::strcpy(response_buffer, error_json.c_str());
     }
@@ -220,12 +319,22 @@ 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,
-                               bool& force_tools) {
+                               bool& force_tools,
+                               size_t& tool_rag_top_k,
+                               float& confidence_threshold,
+                               bool& include_stop_sequences,
+                               bool& use_vad,
+                               bool& telemetry_enabled) {
     temperature = 0.0f;
     top_p = 0.0f;
     top_k = 0;
     max_tokens = 100;
     force_tools = false;
+    tool_rag_top_k = 2;
+    confidence_threshold = 0.7f;
+    include_stop_sequences = false;
+    use_vad = true;
+    telemetry_enabled = true;
     stop_sequences.clear();
 
     if (json.empty()) return;
@@ -261,6 +370,39 @@ inline void parse_options_json(const std::string& json,
         force_tools = (json.substr(pos, 4) == "true");
     }
 
+    pos = json.find("\"tool_rag_top_k\"");
+    if (pos != std::string::npos) {
+        pos = json.find(':', pos) + 1;
+        tool_rag_top_k = std::stoul(json.substr(pos));
+    }
+
+    pos = json.find("\"confidence_threshold\"");
+    if (pos != std::string::npos) {
+        pos = json.find(':', pos) + 1;
+        confidence_threshold = std::stof(json.substr(pos));
+    }
+
+    pos = json.find("\"include_stop_sequences\"");
+    if (pos != std::string::npos) {
+        pos = json.find(':', pos) + 1;
+        while (pos < json.length() && std::isspace(json[pos])) pos++;
+        include_stop_sequences = (json.substr(pos, 4) == "true");
+    }
+
+    pos = json.find("\"use_vad\"");
+    if (pos != std::string::npos) {
+        pos = json.find(':', pos) + 1;
+        while (pos < json.length() && std::isspace(json[pos])) pos++;
+        use_vad = (json.substr(pos, 4) == "true");
+    }
+
+    pos = json.find("\"telemetry_enabled\"");
+    if (pos != std::string::npos) {
+        pos = json.find(':', pos) + 1;
+        while (pos < json.length() && std::isspace(json[pos])) pos++;
+        telemetry_enabled = (json.substr(pos, 4) == "true");
+    }
+
     pos = json.find("\"stop_sequences\"");
     if (pos != std::string::npos) {
         pos = json.find('[', pos);
@@ -297,80 +439,167 @@ inline std::string format_tools_for_prompt(const std::vector<ToolFunction>& tool
     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);
+}
+
+static inline void append_lfm2_call(const std::string& entry,
+                                   std::vector<std::string>& function_calls) {
+    if (entry.empty()) return;
+
+    std::string trimmed_entry = trim_lfm2_slice(entry, 0, entry.size());
+    if (trimmed_entry.empty()) return;
+
+    size_t paren_pos = trimmed_entry.find('(');
+    if (paren_pos == std::string::npos) return;
+
+    std::string func_name = trim_lfm2_slice(trimmed_entry, 0, paren_pos);
+    std::string args_str = trim_lfm2_slice(trimmed_entry, paren_pos + 1, trimmed_entry.size());
+
+    if (!args_str.empty() && args_str.back() == ')') {
+        args_str.pop_back();
+        args_str = trim_lfm2_slice(args_str, 0, args_str.size());
+    }
+
+    std::string json_call = "{\"name\":\"" + func_name + "\",\"arguments\":{";
+
+    size_t arg_pos = 0;
+    bool first_arg = true;
+    while (arg_pos < args_str.length()) {
+        while (arg_pos < args_str.length() && std::isspace(static_cast<unsigned char>(args_str[arg_pos]))) {
+            arg_pos++;
+        }
+
+        size_t eq_pos = args_str.find('=', arg_pos);
+        if (eq_pos == std::string::npos) break;
+
+        std::string arg_name = args_str.substr(arg_pos, eq_pos - arg_pos);
+
+        size_t val_start = eq_pos + 1;
+        size_t val_end = val_start;
+
+        if (val_start < args_str.length() && args_str[val_start] == '"') {
+            val_start++;
+            val_end = args_str.find('"', val_start);
+            if (val_end == std::string::npos) break;
+        } else {
+            val_end = args_str.find(',', val_start);
+            if (val_end == std::string::npos) val_end = args_str.length();
+        }
+
+        std::string arg_value = args_str.substr(val_start, val_end - val_start);
+
+        if (!first_arg) json_call += ",";
+        json_call += "\"" + arg_name + "\":\"" + arg_value + "\"";
+        first_arg = false;
+
+        arg_pos = args_str.find(',', val_end);
+        if (arg_pos != std::string::npos) {
+            arg_pos++;
+        } else {
+            break;
+        }
+    }
+
+    json_call += "}}";
+    function_calls.push_back(json_call);
+}
+
 inline void parse_function_calls_from_response(const std::string& response_text,
                                                std::string& regular_response,
                                                std::vector<std::string>& function_calls) {
     regular_response = response_text;
     function_calls.clear();
 
-    const std::string TOOL_CALL_START = "<|tool_call_start|>";
-    const std::string TOOL_CALL_END = "<|tool_call_end|>";
-    size_t tool_start_pos = 0;
+    gemma::parse_function_calls(regular_response, function_calls);
 
-    while ((tool_start_pos = response_text.find(TOOL_CALL_START, tool_start_pos)) != std::string::npos) {
-        size_t content_start = tool_start_pos + TOOL_CALL_START.length();
-        size_t tool_end_pos = response_text.find(TOOL_CALL_END, content_start);
+    // Parse Qwen-style function calls: <tool_call>{"name": "...", "arguments": {...}}</tool_call>
+    const std::string QWEN_TOOL_START = "<tool_call>";
+    const std::string QWEN_TOOL_END = "</tool_call>";
+    size_t qwen_start_pos = 0;
 
-        if (tool_end_pos != std::string::npos) {
-            std::string tool_content = response_text.substr(content_start, tool_end_pos - content_start);
+    while ((qwen_start_pos = regular_response.find(QWEN_TOOL_START, qwen_start_pos)) != std::string::npos) {
+        size_t content_start = qwen_start_pos + QWEN_TOOL_START.length();
+        size_t qwen_end_pos = regular_response.find(QWEN_TOOL_END, content_start);
 
-            if (tool_content.size() > 2 && tool_content[0] == '[' && tool_content[tool_content.size()-1] == ']') {
-                tool_content = tool_content.substr(1, tool_content.size() - 2); 
+        if (qwen_end_pos != std::string::npos) {
+            std::string json_content = regular_response.substr(content_start, qwen_end_pos - content_start);
 
-                size_t paren_pos = tool_content.find('(');
-                if (paren_pos != std::string::npos) {
-                    std::string func_name = tool_content.substr(0, paren_pos);
-                    std::string args_str = tool_content.substr(paren_pos + 1);
-
-                    if (!args_str.empty() && args_str.back() == ')') {
-                        args_str.pop_back();
-                    }
-
-                    std::string json_call = "{\"name\":\"" + func_name + "\",\"arguments\":{";
-
-                    size_t arg_pos = 0;
-                    bool first_arg = true;
-                    while (arg_pos < args_str.length()) {
-                        while (arg_pos < args_str.length() && std::isspace(args_str[arg_pos])) arg_pos++;
-
-                        size_t eq_pos = args_str.find('=', arg_pos);
-                        if (eq_pos == std::string::npos) break;
+            size_t first = json_content.find_first_not_of(" \t\n\r");
+            size_t last = json_content.find_last_not_of(" \t\n\r");
+            if (first != std::string::npos && last != std::string::npos) {
+                json_content = json_content.substr(first, last - first + 1);
+            }
 
-                        std::string arg_name = args_str.substr(arg_pos, eq_pos - arg_pos);
+            if (json_content.size() > 2 && json_content[0] == '{' &&
+                json_content.find("\"name\"") != std::string::npos) {
+                function_calls.push_back(json_content);
+            }
 
-                        size_t val_start = eq_pos + 1;
-                        size_t val_end = val_start;
+            regular_response.erase(qwen_start_pos, qwen_end_pos + QWEN_TOOL_END.length() - qwen_start_pos);
+        } else {
+            break;
+        }
+    }
+    
+    // Parse LFM2-style function calls: <|tool_call_start|>[name(args)]<|tool_call_end|>
+    const std::string TOOL_CALL_START = "<|tool_call_start|>";
+    const std::string TOOL_CALL_END = "<|tool_call_end|>";
+    size_t tool_start_pos = 0;
 
-                        if (val_start < args_str.length() && args_str[val_start] == '"') {
-                            val_start++;
-                            val_end = args_str.find('"', val_start);
-                            if (val_end == std::string::npos) break;
-                        } else {
-                            val_end = args_str.find(',', val_start);
-                            if (val_end == std::string::npos) val_end = args_str.length();
-                        }
+    while ((tool_start_pos = regular_response.find(TOOL_CALL_START, tool_start_pos)) != std::string::npos) {
+        size_t content_start = tool_start_pos + TOOL_CALL_START.length();
+        size_t tool_end_pos = regular_response.find(TOOL_CALL_END, content_start);
 
-                        std::string arg_value = args_str.substr(val_start, val_end - val_start);
+        if (tool_end_pos != std::string::npos) {
+            std::string tool_content = regular_response.substr(content_start, tool_end_pos - content_start);
+            std::string content = tool_content;
+            size_t trim_start = 0;
+            while (trim_start < content.size() && std::isspace(static_cast<unsigned char>(content[trim_start]))) {
+                trim_start++;
+            }
 
-                        if (!first_arg) json_call += ",";
-                        json_call += "\"" + arg_name + "\":\"" + arg_value + "\"";
-                        first_arg = false;
+            if (trim_start < content.size()) {
+                size_t trim_end = content.size() - 1;
+                while (trim_end > trim_start && std::isspace(static_cast<unsigned char>(content[trim_end]))) {
+                    trim_end--;
+                }
+                content = content.substr(trim_start, trim_end - trim_start + 1);
+            } else {
+                content.clear();
+            }
 
-                        arg_pos = args_str.find(',', val_end);
-                        if (arg_pos != std::string::npos) {
-                            arg_pos++;
-                        } else {
-                            break;
-                        }
+            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;
                     }
+                }
 
-                    json_call += "}}";
-                    function_calls.push_back(json_call);
+                if (start < inner.size()) {
+                    append_lfm2_call(inner.substr(start), function_calls);
                 }
+            } else if (!content.empty()) {
+                append_lfm2_call(content, function_calls);
             }
 
             regular_response.erase(tool_start_pos, tool_end_pos + TOOL_CALL_END.length() - tool_start_pos);
-            tool_start_pos = tool_end_pos + TOOL_CALL_END.length();
         } else {
             break;
         }
@@ -411,38 +640,71 @@ inline std::string construct_response_json(const std::string& regular_response,
                                            const std::vector<std::string>& function_calls,
                                            double time_to_first_token,
                                            double total_time_ms,
-                                           double tokens_per_second,
+                                           double prefill_tps,
+                                           double decode_tps,
                                            size_t prompt_tokens,
-                                           size_t completion_tokens) {
-    std::ostringstream json_response;
-    json_response << "{";
-    json_response << "\"success\":true,";
-    json_response << "\"response\":\"";
-    for (char c : regular_response) {
-        if (c == '"') json_response << "\\\"";
-        else if (c == '\n') json_response << "\\n";
-        else if (c == '\r') json_response << "\\r";
-        else if (c == '\t') json_response << "\\t";
-        else if (c == '\\') json_response << "\\\\";
-        else json_response << c;
+                                           size_t completion_tokens,
+                                           float confidence = 0.0f,
+                                           bool cloud_handoff = false) {
+    std::ostringstream json;
+    json << "{";
+    json << "\"success\":" << (cloud_handoff ? "false" : "true") << ",";
+    json << "\"error\":null,";
+    json << "\"cloud_handoff\":" << (cloud_handoff ? "true" : "false") << ",";
+    json << "\"response\":\"" << escape_json_string(regular_response) << "\",";
+    json << "\"function_calls\":[";
+    for (size_t i = 0; i < function_calls.size(); ++i) {
+        if (i > 0) json << ",";
+        json << function_calls[i];
     }
-    json_response << "\",";
-    if (!function_calls.empty()) {
-        json_response << "\"function_calls\":[";
-        for (size_t i = 0; i < function_calls.size(); ++i) {
-            if (i > 0) json_response << ",";
-            json_response << function_calls[i];
-        }
-        json_response << "],";
+    json << "],";
+    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) << total_time_ms << ",";
+    json << "\"prefill_tps\":" << std::fixed << std::setprecision(2) << prefill_tps << ",";
+    json << "\"decode_tps\":" << std::fixed << std::setprecision(2) << decode_tps << ",";
+    json << "\"ram_usage_mb\":" << std::fixed << std::setprecision(2) << get_ram_usage_mb() << ",";
+    json << "\"prefill_tokens\":" << prompt_tokens << ",";
+    json << "\"decode_tokens\":" << completion_tokens << ",";
+    json << "\"total_tokens\":" << (prompt_tokens + completion_tokens);
+    json << "}";
+    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;
+    oss << "[";
+    for (size_t i = 0; i < calls.size(); ++i) {
+        if (i > 0) oss << ",";
+        oss << calls[i];
     }
-    json_response << "\"time_to_first_token_ms\":" << std::fixed << std::setprecision(2) << time_to_first_token << ",";
-    json_response << "\"total_time_ms\":" << std::fixed << std::setprecision(2) << total_time_ms << ",";
-    json_response << "\"tokens_per_second\":" << std::fixed << std::setprecision(2) << tokens_per_second << ",";
-    json_response << "\"prefill_tokens\":" << prompt_tokens << ",";
-    json_response << "\"decode_tokens\":" << completion_tokens << ",";
-    json_response << "\"total_tokens\":" << (prompt_tokens + completion_tokens);
-    json_response << "}";
-    return json_response.str();
+    oss << "]";
+    return oss.str();
 }
 
 } // namespace ffi
@@ -454,35 +716,8 @@ extern "C" {
 
 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