cactus-react-native 0.0.1 → 0.1.1

package/ios/CactusContext.mm

@@ -82,7 +82,7 @@
     BOOL isAsset = [params[@"is_model_asset"] boolValue];
     NSString *path = modelPath;
     if (isAsset) path = [[NSBundle mainBundle] pathForResource:modelPath ofType:nil];
-    defaultParams.model = [path UTF8String];
+    defaultParams.model.path = [path UTF8String];
 
     NSString *chatTemplate = params[@"chat_template"];
     if (chatTemplate) {
@@ -700,6 +700,25 @@
     return result;
 }
 
+- (NSArray *)tokenize:(NSString *)text withMediaPaths:(NSArray *)mediaPaths {
+    std::vector<std::string> media_paths_vector;
+    if (mediaPaths) {
+        for (NSString *mediaPath in mediaPaths) {
+            media_paths_vector.push_back([mediaPath UTF8String]);
+        }
+    }
+    
+    cactus::cactus_tokenize_result tokenize_result = llama->tokenize([text UTF8String], media_paths_vector);
+    
+    // Return just the tokens array to match the method signature
+    NSMutableArray *tokens = [[NSMutableArray alloc] init];
+    for (const auto &tok : tokenize_result.tokens) {
+        [tokens addObject:@(tok)];
+    }
+    
+    return tokens;
+}
+
 - (NSString *)detokenize:(NSArray *)tokens {
     std::vector<llama_token> toks;
     for (NSNumber *tok in tokens) {
@@ -827,9 +846,165 @@
     return result;
 }
 
+// New Multimodal Methods
+- (BOOL)initMultimodal:(NSString *)mmprojPath useGpu:(BOOL)useGpu {
+    return llama->initMultimodal([mmprojPath UTF8String], useGpu);
+}
+
+- (BOOL)isMultimodalEnabled {
+    return llama->isMultimodalEnabled();
+}
+
+- (BOOL)isMultimodalSupportVision {
+    return llama->isMultimodalSupportVision();
+}
+
+- (BOOL)isMultimodalSupportAudio {
+    return llama->isMultimodalSupportAudio();
+}
+
+- (void)releaseMultimodal {
+    llama->releaseMultimodal();
+}
+
+- (NSDictionary *)multimodalCompletion:(NSString *)prompt 
+    withMediaPaths:(NSArray *)mediaPaths 
+    params:(NSDictionary *)params 
+    onToken:(void (^)(NSMutableDictionary *tokenResult))onToken {
+    
+    if (!llama->isMultimodalEnabled()) {
+        @throw [NSException exceptionWithName:@"LlamaException" reason:@"Multimodal is not enabled" userInfo:nil];
+    }
+    
+    llama->rewind();
+    
+    llama->params.prompt = [prompt UTF8String];
+    llama->params.sampling.seed = params[@"seed"] ? [params[@"seed"] intValue] : -1;
+    
+    // Set all completion parameters (similar to existing completion method)
+    if (params[@"n_threads"]) {
+        int nThreads = [params[@"n_threads"] intValue];
+        const int maxThreads = (int) [[NSProcessInfo processInfo] processorCount];
+        const int defaultNThreads = nThreads == 4 ? 2 : MIN(4, maxThreads);
+        llama->params.cpuparams.n_threads = nThreads > 0 ? nThreads : defaultNThreads;
+    }
+    if (params[@"n_predict"]) llama->params.n_predict = [params[@"n_predict"] intValue];
+    if (params[@"ignore_eos"]) llama->params.sampling.ignore_eos = [params[@"ignore_eos"] boolValue];
+    
+    auto & sparams = llama->params.sampling;
+    if (params[@"temperature"]) sparams.temp = [params[@"temperature"] doubleValue];
+    if (params[@"top_k"]) sparams.top_k = [params[@"top_k"] intValue];
+    if (params[@"top_p"]) sparams.top_p = [params[@"top_p"] doubleValue];
+    
+    // Convert media paths
+    std::vector<std::string> media_paths_vector;
+    if (mediaPaths) {
+        for (NSString *mediaPath in mediaPaths) {
+            media_paths_vector.push_back([mediaPath UTF8String]);
+        }
+    }
+    
+    if (!llama->initSampling()) {
+        @throw [NSException exceptionWithName:@"LlamaException" reason:@"Failed to initialize sampling" userInfo:nil];
+    }
+    
+    llama->beginCompletion();
+    
+    @try {
+        llama->loadPrompt(media_paths_vector);
+    } @catch (NSException *exception) {
+        @throw [NSException exceptionWithName:@"LlamaException" reason:exception.reason userInfo:nil];
+    }
+    
+    size_t sent_count = 0;
+    while (llama->has_next_token && !llama->is_interrupted) {
+        const cactus::completion_token_output token_with_probs = llama->doCompletion();
+        if (token_with_probs.tok == -1 || llama->incomplete) {
+            continue;
+        }
+        
+        const std::string token_text = common_token_to_piece(llama->ctx, token_with_probs.tok);
+        size_t pos = std::min(sent_count, llama->generated_text.size());
+        const std::string str_test = llama->generated_text.substr(pos);
+        
+        size_t stop_pos = llama->findStoppingStrings(str_test, token_text.size(), cactus::STOP_FULL);
+        
+        if (stop_pos == std::string::npos || (!llama->has_next_token && stop_pos > 0)) {
+            const std::string to_send = llama->generated_text.substr(pos, std::string::npos);
+            sent_count += to_send.size();
+            
+            if (onToken) {
+                NSMutableDictionary *tokenResult = [[NSMutableDictionary alloc] init];
+                tokenResult[@"token"] = [NSString stringWithUTF8String:to_send.c_str()];
+                onToken(tokenResult);
+            }
+        }
+    }
+    
+    llama->is_predicting = false;
+    
+    NSMutableDictionary *result = [[NSMutableDictionary alloc] init];
+    result[@"text"] = [NSString stringWithUTF8String:llama->generated_text.c_str()];
+    result[@"tokens_predicted"] = @(llama->num_tokens_predicted);
+    result[@"tokens_evaluated"] = @(llama->num_prompt_tokens);
+    result[@"truncated"] = @(llama->truncated);
+    result[@"stopped_eos"] = @(llama->stopped_eos);
+    result[@"stopped_word"] = @(llama->stopped_word);
+    result[@"stopped_limit"] = @(llama->stopped_limit);
+    result[@"stopping_word"] = [NSString stringWithUTF8String:llama->stopping_word.c_str()];
+    result[@"tokens_cached"] = @(llama->n_past);
+    
+    return result;
+}
+
+- (void)releaseVocoder {
+    llama->releaseVocoder();
+}
+
 - (void)invalidate {
     delete llama;
     // llama_backend_free();
 }
 
+// New TTS/Vocoder Methods
+- (BOOL)initVocoder:(NSString *)vocoderModelPath {
+    return llama->initVocoder([vocoderModelPath UTF8String]);
+}
+
+- (BOOL)isVocoderEnabled {
+    return llama->isVocoderEnabled();
+}
+
+- (int)getTTSType {
+    return static_cast<int>(llama->getTTSType());
+}
+
+- (NSString *)getFormattedAudioCompletion:(NSString *)speakerJsonStr textToSpeak:(NSString *)textToSpeak {
+    std::string result = llama->getFormattedAudioCompletion([speakerJsonStr UTF8String], [textToSpeak UTF8String]);
+    return [NSString stringWithUTF8String:result.c_str()];
+}
+
+- (NSArray *)getAudioCompletionGuideTokens:(NSString *)textToSpeak {
+    std::vector<llama_token> tokens = llama->getAudioCompletionGuideTokens([textToSpeak UTF8String]);
+    NSMutableArray *result = [[NSMutableArray alloc] init];
+    for (const auto &token : tokens) {
+        [result addObject:@(token)];
+    }
+    return result;
+}
+
+- (NSArray *)decodeAudioTokens:(NSArray *)tokens {
+    std::vector<llama_token> token_vector;
+    for (NSNumber *token in tokens) {
+        token_vector.push_back([token intValue]);
+    }
+    
+    std::vector<float> audio_data = llama->decodeAudioTokens(token_vector);
+    NSMutableArray *result = [[NSMutableArray alloc] init];
+    for (const auto &sample : audio_data) {
+        [result addObject:@(sample)];
+    }
+    return result;
+}
+
 @end

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

@@ -14,6 +14,8 @@
 #include <android/log.h>
 #endif
 
+struct mtmd_context;
+
 namespace cactus {
 
 std::string tokens_to_output_formatted_string(const llama_context *ctx, const llama_token token);
@@ -28,7 +30,12 @@ enum stop_type
     STOP_PARTIAL,
 };
 
-// completion token output with probabilities
+enum tts_type {
+    TTS_UNKNOWN = -1,
+    TTS_OUTETTS_V0_2 = 1,
+    TTS_OUTETTS_V0_3 = 2,
+};
+
 struct completion_token_output
 {
     struct token_prob
@@ -41,7 +48,14 @@ struct completion_token_output
     llama_token tok;
 };
 
-// Main context class
+struct cactus_tokenize_result {
+    std::vector<llama_token> tokens;
+    bool has_media = false;
+    std::vector<std::string> bitmap_hashes;
+    std::vector<size_t> chunk_pos;
+    std::vector<size_t> chunk_pos_media;
+};
+
 struct cactus_context {
     bool is_predicting = false;
     bool is_interrupted = false;
@@ -77,12 +91,37 @@ struct cactus_context {
 
     std::vector<common_adapter_lora_info> lora;
 
+    bool context_full = false;
+    std::vector<llama_token> guide_tokens;
+    bool next_token_uses_guide_token = true;
+
+    struct cactus_context_mtmd {
+        mtmd_context* mtmd_ctx = nullptr;
+    };
+    cactus_context_mtmd *mtmd_wrapper = nullptr;
+    bool has_multimodal = false;
+    std::vector<std::string> mtmd_bitmap_past_hashes;
+
+    struct cactus_context_vocoder {
+        common_init_result init_result;
+        llama_model *model = nullptr;
+        llama_context *ctx = nullptr;
+        tts_type type = TTS_UNKNOWN;
+    };
+    cactus_context_vocoder *vocoder_wrapper = nullptr;
+    bool has_vocoder = false;
+    std::vector<llama_token> audio_tokens;
+
     ~cactus_context();
 
     void rewind();
+
     bool initSampling();
+
     bool loadModel(common_params &params_);
+
     bool validateModelChatTemplate(bool use_jinja, const char *name) const;
+
     common_chat_params getFormattedChatWithJinja(
       const std::string &messages,
       const std::string &chat_template,
@@ -91,24 +130,58 @@ struct cactus_context {
       const bool &parallel_tool_calls,
       const std::string &tool_choice
     ) const;
+
     std::string getFormattedChat(
       const std::string &messages,
       const std::string &chat_template
     ) const;
+    
     void truncatePrompt(std::vector<llama_token> &prompt_tokens);
+
     void loadPrompt();
+
+    void loadPrompt(const std::vector<std::string> &media_paths);
+
+    void setGuideTokens(const std::vector<llama_token> &tokens);
+   
     void beginCompletion();
+
+    void endCompletion();
+    
     completion_token_output nextToken();
+   
     size_t findStoppingStrings(const std::string &text, const size_t last_token_size, const stop_type type);
+   
     completion_token_output doCompletion();
+   
     std::vector<float> getEmbedding(common_params &embd_params);
+    
     std::string bench(int pp, int tg, int pl, int nr);
+   
     int applyLoraAdapters(std::vector<common_adapter_lora_info> lora);
+   
     void removeLoraAdapters();
+    
     std::vector<common_adapter_lora_info> getLoadedLoraAdapters();
-};\
 
-// Logging macros
+    cactus_tokenize_result tokenize(const std::string &text, const std::vector<std::string> &media_paths);
+
+    bool initMultimodal(const std::string &mmproj_path, bool use_gpu);
+    bool isMultimodalEnabled() const;
+    bool isMultimodalSupportVision() const;
+    bool isMultimodalSupportAudio() const;
+    void releaseMultimodal();
+    void processMedia(const std::string &prompt, const std::vector<std::string> &media_paths);
+
+    bool initVocoder(const std::string &vocoder_model_path);
+    bool isVocoderEnabled() const;
+    tts_type getTTSType() const;
+    std::string getFormattedAudioCompletion(const std::string &speaker_json_str, const std::string &text_to_speak);
+    std::vector<llama_token> getAudioCompletionGuideTokens(const std::string &text_to_speak);
+    std::vector<float> decodeAudioTokens(const std::vector<llama_token> &tokens);
+    void releaseVocoder();
+};
+
 extern bool cactus_verbose;
 
 #if CACTUS_VERBOSE != 1
@@ -125,9 +198,23 @@ extern bool cactus_verbose;
 #endif
 
 #define LOG_ERROR(MSG, ...) log("ERROR", __func__, __LINE__, MSG, ##__VA_ARGS__)
+
 #define LOG_WARNING(MSG, ...) log("WARNING", __func__, __LINE__, MSG, ##__VA_ARGS__)
+
 #define LOG_INFO(MSG, ...) log("INFO", __func__, __LINE__, MSG, ##__VA_ARGS__)
 
+void log(const char *level, const char *function, int line, const char *format, ...);
+
+void llama_batch_clear(llama_batch *batch);
+
+void llama_batch_add(llama_batch *batch, llama_token id, llama_pos pos, const std::vector<llama_seq_id>& seq_ids, bool logits);
+
+size_t common_part(const std::vector<llama_token> &a, const std::vector<llama_token> &b);
+
+bool ends_with(const std::string &str, const std::string &suffix);
+
+size_t find_partial_stop_string(const std::string &stop, const std::string &text);
+
 } // namespace cactus
 
-#endif /* CACTUS_H */
+#endif /* CACTUS_H */

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

@@ -0,0 +1,268 @@
+#ifndef CACTUS_FFI_H
+#define CACTUS_FFI_H
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+
+#if defined _WIN32 || defined __CYGWIN__
+  #ifdef CACTUS_FFI_BUILDING_DLL
+    #ifdef __GNUC__
+      #define CACTUS_FFI_EXPORT __attribute__ ((dllexport))
+    #else
+      #define CACTUS_FFI_EXPORT __declspec(dllexport)
+    #endif
+  #else
+    #ifdef __GNUC__
+      #define CACTUS_FFI_EXPORT __attribute__ ((dllimport))
+    #else
+      #define CACTUS_FFI_EXPORT __declspec(dllimport)
+    #endif
+  #endif
+  #define CACTUS_FFI_LOCAL
+#else
+  #if __GNUC__ >= 4
+    #define CACTUS_FFI_EXPORT __attribute__ ((visibility ("default")))
+    #define CACTUS_FFI_LOCAL  __attribute__ ((visibility ("hidden")))
+  #else
+    #define CACTUS_FFI_EXPORT
+    #define CACTUS_FFI_LOCAL
+  #endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct cactus_context_opaque* cactus_context_handle_t;
+
+
+typedef struct cactus_init_params_c {
+    const char* model_path;
+    const char* chat_template; 
+
+    int32_t n_ctx;
+    int32_t n_batch;
+    int32_t n_ubatch;
+    int32_t n_gpu_layers;
+    int32_t n_threads;
+    bool use_mmap;
+    bool use_mlock;
+    bool embedding; 
+    int32_t pooling_type; 
+    int32_t embd_normalize;
+    bool flash_attn;
+    const char* cache_type_k; 
+    const char* cache_type_v; 
+    void (*progress_callback)(float progress); 
+
+} cactus_init_params_c_t;
+
+typedef struct cactus_completion_params_c {
+    const char* prompt;
+    int32_t n_predict; 
+    int32_t n_threads; 
+    int32_t seed;
+    double temperature;
+    int32_t top_k;
+    double top_p;
+    double min_p;
+    double typical_p;
+    int32_t penalty_last_n;
+    double penalty_repeat;
+    double penalty_freq;
+    double penalty_present;
+    int32_t mirostat;
+    double mirostat_tau;
+    double mirostat_eta;
+    bool ignore_eos;
+    int32_t n_probs; 
+    const char** stop_sequences; 
+    int stop_sequence_count;
+    const char* grammar; 
+    bool (*token_callback)(const char* token_json);
+
+} cactus_completion_params_c_t;
+
+
+typedef struct cactus_token_array_c {
+    int32_t* tokens;
+    int32_t count;
+} cactus_token_array_c_t;
+
+typedef struct cactus_float_array_c {
+    float* values;
+    int32_t count;
+} cactus_float_array_c_t;
+
+typedef struct cactus_completion_result_c {
+    char* text; 
+    int32_t tokens_predicted;
+    int32_t tokens_evaluated;
+    bool truncated;
+    bool stopped_eos;
+    bool stopped_word;
+    bool stopped_limit;
+    char* stopping_word; 
+} cactus_completion_result_c_t;
+
+typedef struct cactus_tokenize_result_c {
+    cactus_token_array_c_t tokens;
+    bool has_media;
+    char** bitmap_hashes;
+    int bitmap_hash_count;
+    size_t* chunk_positions;
+    int chunk_position_count;
+    size_t* chunk_positions_media;
+    int chunk_position_media_count;
+} cactus_tokenize_result_c_t;
+
+CACTUS_FFI_EXPORT cactus_context_handle_t cactus_init_context_c(const cactus_init_params_c_t* params);
+
+CACTUS_FFI_EXPORT void cactus_free_context_c(cactus_context_handle_t handle);
+
+CACTUS_FFI_EXPORT int cactus_completion_c(
+    cactus_context_handle_t handle,
+    const cactus_completion_params_c_t* params,
+    cactus_completion_result_c_t* result
+);
+
+// **MULTIMODAL COMPLETION**
+CACTUS_FFI_EXPORT int cactus_multimodal_completion_c(
+    cactus_context_handle_t handle,
+    const cactus_completion_params_c_t* params,
+    const char** media_paths,
+    int media_count,
+    cactus_completion_result_c_t* result
+);
+
+CACTUS_FFI_EXPORT void cactus_stop_completion_c(cactus_context_handle_t handle);
+
+CACTUS_FFI_EXPORT cactus_token_array_c_t cactus_tokenize_c(cactus_context_handle_t handle, const char* text);
+
+CACTUS_FFI_EXPORT char* cactus_detokenize_c(cactus_context_handle_t handle, const int32_t* tokens, int32_t count);
+
+CACTUS_FFI_EXPORT cactus_float_array_c_t cactus_embedding_c(cactus_context_handle_t handle, const char* text);
+
+CACTUS_FFI_EXPORT void cactus_free_string_c(char* str);
+
+CACTUS_FFI_EXPORT void cactus_free_token_array_c(cactus_token_array_c_t arr);
+
+CACTUS_FFI_EXPORT void cactus_free_float_array_c(cactus_float_array_c_t arr);
+
+CACTUS_FFI_EXPORT void cactus_free_completion_result_members_c(cactus_completion_result_c_t* result);
+
+CACTUS_FFI_EXPORT cactus_tokenize_result_c_t cactus_tokenize_with_media_c(cactus_context_handle_t handle, const char* text, const char** media_paths, int media_count);
+
+CACTUS_FFI_EXPORT void cactus_free_tokenize_result_c(cactus_tokenize_result_c_t* result);
+
+CACTUS_FFI_EXPORT void cactus_set_guide_tokens_c(cactus_context_handle_t handle, const int32_t* tokens, int32_t count);
+
+CACTUS_FFI_EXPORT int cactus_init_multimodal_c(cactus_context_handle_t handle, const char* mmproj_path, bool use_gpu);
+
+CACTUS_FFI_EXPORT bool cactus_is_multimodal_enabled_c(cactus_context_handle_t handle);
+
+CACTUS_FFI_EXPORT bool cactus_supports_vision_c(cactus_context_handle_t handle);
+
+CACTUS_FFI_EXPORT bool cactus_supports_audio_c(cactus_context_handle_t handle);
+
+CACTUS_FFI_EXPORT void cactus_release_multimodal_c(cactus_context_handle_t handle);
+
+CACTUS_FFI_EXPORT int cactus_init_vocoder_c(cactus_context_handle_t handle, const char* vocoder_model_path);
+
+CACTUS_FFI_EXPORT bool cactus_is_vocoder_enabled_c(cactus_context_handle_t handle);
+
+CACTUS_FFI_EXPORT int cactus_get_tts_type_c(cactus_context_handle_t handle);
+
+CACTUS_FFI_EXPORT char* cactus_get_formatted_audio_completion_c(cactus_context_handle_t handle, const char* speaker_json_str, const char* text_to_speak);
+
+CACTUS_FFI_EXPORT cactus_token_array_c_t cactus_get_audio_guide_tokens_c(cactus_context_handle_t handle, const char* text_to_speak);
+
+CACTUS_FFI_EXPORT cactus_float_array_c_t cactus_decode_audio_tokens_c(cactus_context_handle_t handle, const int32_t* tokens, int32_t count);
+
+CACTUS_FFI_EXPORT void cactus_release_vocoder_c(cactus_context_handle_t handle);
+
+// **HIGH PRIORITY ADDITIONS**
+
+typedef struct {
+    const char* path;
+    float scale;
+} cactus_lora_adapter_c_t;
+
+typedef struct {
+    cactus_lora_adapter_c_t* adapters;
+    int32_t count;
+} cactus_lora_adapters_c_t;
+
+typedef struct {
+    char* model_name;
+    int64_t model_size;
+    int64_t model_params;
+    double pp_avg;
+    double pp_std;
+    double tg_avg;
+    double tg_std;
+} cactus_bench_result_c_t;
+
+// **HIGH PRIORITY: Benchmarking**
+CACTUS_FFI_EXPORT cactus_bench_result_c_t cactus_bench_c(cactus_context_handle_t handle, int pp, int tg, int pl, int nr);
+
+// **HIGH PRIORITY: LoRA Adapter Support**
+CACTUS_FFI_EXPORT int cactus_apply_lora_adapters_c(cactus_context_handle_t handle, const cactus_lora_adapters_c_t* adapters);
+CACTUS_FFI_EXPORT void cactus_remove_lora_adapters_c(cactus_context_handle_t handle);
+CACTUS_FFI_EXPORT cactus_lora_adapters_c_t cactus_get_loaded_lora_adapters_c(cactus_context_handle_t handle);
+
+// **HIGH PRIORITY: Chat Template Support**
+CACTUS_FFI_EXPORT bool cactus_validate_chat_template_c(cactus_context_handle_t handle, bool use_jinja, const char* name);
+CACTUS_FFI_EXPORT char* cactus_get_formatted_chat_c(cactus_context_handle_t handle, const char* messages, const char* chat_template);
+
+// **ADVANCED: Chat with Jinja and Tools Support**
+typedef struct {
+    char* prompt;
+    char* json_schema;
+    char* tools;
+    char* tool_choice;
+    bool parallel_tool_calls;
+} cactus_chat_result_c_t;
+
+CACTUS_FFI_EXPORT cactus_chat_result_c_t cactus_get_formatted_chat_with_jinja_c(
+    cactus_context_handle_t handle, 
+    const char* messages,
+    const char* chat_template,
+    const char* json_schema,
+    const char* tools,
+    bool parallel_tool_calls,
+    const char* tool_choice
+);
+
+// **HIGH PRIORITY: Context Management**
+CACTUS_FFI_EXPORT void cactus_rewind_c(cactus_context_handle_t handle);
+CACTUS_FFI_EXPORT bool cactus_init_sampling_c(cactus_context_handle_t handle);
+
+// **COMPLETION CONTROL**
+CACTUS_FFI_EXPORT void cactus_begin_completion_c(cactus_context_handle_t handle);
+CACTUS_FFI_EXPORT void cactus_end_completion_c(cactus_context_handle_t handle);
+CACTUS_FFI_EXPORT void cactus_load_prompt_c(cactus_context_handle_t handle);
+CACTUS_FFI_EXPORT void cactus_load_prompt_with_media_c(cactus_context_handle_t handle, const char** media_paths, int media_count);
+
+// **TOKEN PROCESSING**
+CACTUS_FFI_EXPORT int cactus_do_completion_step_c(cactus_context_handle_t handle, char** token_text);
+CACTUS_FFI_EXPORT size_t cactus_find_stopping_strings_c(cactus_context_handle_t handle, const char* text, size_t last_token_size, int stop_type);
+
+// **HIGH PRIORITY: Model Information**
+CACTUS_FFI_EXPORT int32_t cactus_get_n_ctx_c(cactus_context_handle_t handle);
+CACTUS_FFI_EXPORT int32_t cactus_get_n_embd_c(cactus_context_handle_t handle);
+CACTUS_FFI_EXPORT char* cactus_get_model_desc_c(cactus_context_handle_t handle);
+CACTUS_FFI_EXPORT int64_t cactus_get_model_size_c(cactus_context_handle_t handle);
+CACTUS_FFI_EXPORT int64_t cactus_get_model_params_c(cactus_context_handle_t handle);
+
+// Memory management functions
+CACTUS_FFI_EXPORT void cactus_free_bench_result_members_c(cactus_bench_result_c_t* result);
+CACTUS_FFI_EXPORT void cactus_free_lora_adapters_c(cactus_lora_adapters_c_t* adapters);
+CACTUS_FFI_EXPORT void cactus_free_chat_result_members_c(cactus_chat_result_c_t* result);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

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

@@ -3,6 +3,7 @@
 #pragma once
 
 #include "common.h"
+#include <chrono>
 #include <string>
 #include <vector>
 #include "minja/chat-template.hpp"
@@ -79,6 +80,7 @@ struct common_chat_templates_inputs {
     common_chat_tool_choice tool_choice = COMMON_CHAT_TOOL_CHOICE_AUTO;
     bool parallel_tool_calls = false;
     bool extract_reasoning     = true;
+    std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
 };
 
 struct common_chat_params {