cactus-react-native 0.0.1 → 0.1.0

package/ios/cactus.xcframework/tvos-arm64_x86_64-simulator/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/tvos-arm64_x86_64-simulator/cactus.framework/Headers/cactus_ffi.h

@@ -0,0 +1,229 @@
+#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
+);
+
+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);
+
+// **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);
+
+// **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);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/ios/cactus.xcframework/tvos-arm64_x86_64-simulator/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 {

package/ios/cactus.xcframework/tvos-arm64_x86_64-simulator/cactus.framework/Headers/common.h

@@ -6,6 +6,7 @@
 
 #include <set>
 #include <string>
+#include <string_view>
 #include <vector>
 #include <sstream>
 
@@ -42,17 +43,6 @@ extern const char * LLAMA_BUILD_TARGET;
 
 struct common_control_vector_load_info;
 
-#define print_build_info() do {                                                                     \
-    fprintf(stderr, "%s: build = %d (%s)\n", __func__, LLAMA_BUILD_NUMBER, LLAMA_COMMIT);           \
-    fprintf(stderr, "%s: built with %s for %s\n", __func__, LLAMA_COMPILER, LLAMA_BUILD_TARGET);    \
-} while(0)
-
-// build info
-extern int LLAMA_BUILD_NUMBER;
-extern char const *LLAMA_COMMIT;
-extern char const *LLAMA_COMPILER;
-extern char const *LLAMA_BUILD_TARGET;
-
 //
 // CPU utils
 //
@@ -77,7 +67,6 @@ enum llama_example {
     LLAMA_EXAMPLE_COMMON,
     LLAMA_EXAMPLE_SPECULATIVE,
     LLAMA_EXAMPLE_MAIN,
-    LLAMA_EXAMPLE_INFILL,
     LLAMA_EXAMPLE_EMBEDDING,
     LLAMA_EXAMPLE_PERPLEXITY,
     LLAMA_EXAMPLE_RETRIEVAL,
@@ -87,7 +76,7 @@ enum llama_example {
     LLAMA_EXAMPLE_SERVER,
     LLAMA_EXAMPLE_CVECTOR_GENERATOR,
     LLAMA_EXAMPLE_EXPORT_LORA,
-    LLAMA_EXAMPLE_LLAVA,
+    LLAMA_EXAMPLE_MTMD,
     LLAMA_EXAMPLE_LOOKUP,
     LLAMA_EXAMPLE_PARALLEL,
     LLAMA_EXAMPLE_TTS,
@@ -107,6 +96,7 @@ enum common_sampler_type {
     COMMON_SAMPLER_TYPE_XTC         = 8,
     COMMON_SAMPLER_TYPE_INFILL      = 9,
     COMMON_SAMPLER_TYPE_PENALTIES   = 10,
+    COMMON_SAMPLER_TYPE_TOP_N_SIGMA = 11,
 };
 
 // dimensionality reduction methods, used by cvector-generator
@@ -132,10 +122,6 @@ struct common_grammar_trigger {
     common_grammar_trigger_type type;
     std::string value;
     llama_token token = LLAMA_TOKEN_NULL;
-
-    // T can only be nlohmann::ordered_json
-    template <class T> T to_json() const;
-    template <class T> static common_grammar_trigger from_json(const T & in);
 };
 
 // sampling parameters
@@ -176,6 +162,7 @@ struct common_params_sampling {
     std::vector<enum common_sampler_type> samplers = {
         COMMON_SAMPLER_TYPE_PENALTIES,
         COMMON_SAMPLER_TYPE_DRY,
+        COMMON_SAMPLER_TYPE_TOP_N_SIGMA,
         COMMON_SAMPLER_TYPE_TOP_K,
         COMMON_SAMPLER_TYPE_TYPICAL_P,
         COMMON_SAMPLER_TYPE_TOP_P,
@@ -195,6 +182,13 @@ struct common_params_sampling {
     std::string print() const;
 };
 
+struct common_params_model {
+    std::string path    = ""; // model local path                                           // NOLINT
+    std::string url     = ""; // model url to download                                      // NOLINT
+    std::string hf_repo = ""; // HF repo                                                    // NOLINT
+    std::string hf_file = ""; // HF file                                                    // NOLINT
+};
+
 struct common_params_speculative {
     std::vector<lm_ggml_backend_dev_t> devices; // devices to use for offloading
 
@@ -208,19 +202,11 @@ struct common_params_speculative {
     struct cpu_params cpuparams;
     struct cpu_params cpuparams_batch;
 
-    std::string hf_repo = ""; // HF repo                                                     // NOLINT
-    std::string hf_file = ""; // HF file                                                     // NOLINT
-
-    std::string model = "";     // draft model for speculative decoding                      // NOLINT
-    std::string model_url = ""; // model url to download                                     // NOLINT
+    struct common_params_model model;
 };
 
 struct common_params_vocoder {
-    std::string hf_repo = ""; // HF repo                                                     // NOLINT
-    std::string hf_file = ""; // HF file                                                     // NOLINT
-
-    std::string model     = ""; // model path                                                // NOLINT
-    std::string model_url = ""; // model url to download                                     // NOLINT
+    struct common_params_model model;
 
     std::string speaker_file = ""; // speaker file path                                      // NOLINT
 
@@ -279,12 +265,10 @@ struct common_params {
     struct common_params_speculative speculative;
     struct common_params_vocoder     vocoder;
 
-    std::string model                = ""; // model path                                                    // NOLINT
+    struct common_params_model model;
+
     std::string model_alias          = ""; // model alias                                                   // NOLINT
-    std::string model_url            = ""; // model url to download                                         // NOLINT
     std::string hf_token             = ""; // HF token                                                      // NOLINT
-    std::string hf_repo              = ""; // HF repo                                                       // NOLINT
-    std::string hf_file              = ""; // HF file                                                       // NOLINT
     std::string prompt               = "";                                                                  // NOLINT
     std::string system_prompt        = "";                                                                  // NOLINT
     std::string prompt_file          = ""; // store the external prompt file name                           // NOLINT
@@ -298,6 +282,7 @@ struct common_params {
     std::vector<std::string> in_files;   // all input files
     std::vector<std::string> antiprompt; // strings upon which more user input is prompted (a.k.a. reverse prompts)
     std::vector<llama_model_kv_override> kv_overrides;
+    std::vector<llama_model_tensor_buft_override> tensor_buft_overrides;
 
     bool lora_init_without_apply = false; // only load lora to memory, but do not apply it to ctx (user can manually apply lora later using llama_adapter_lora_apply)
     std::vector<common_adapter_lora_info> lora_adapters; // lora adapter path with user defined scale
@@ -339,17 +324,17 @@ struct common_params {
     bool flash_attn        = false; // flash attention
     bool no_perf           = false; // disable performance metrics
     bool ctx_shift         = true;  // context shift on inifinite text generation
+    bool swa_full          = false; // use full-size SWA cache (https://github.com/ggml-org/llama.cpp/pull/13194#issuecomment-2868343055)
 
     bool input_prefix_bos  = false; // prefix BOS to user inputs, preceding input_prefix
-    bool logits_all        = false; // return logits for all tokens in the batch
     bool use_mmap          = true;  // use mmap for faster loads
     bool use_mlock         = false; // use mlock to keep model in memory
     bool verbose_prompt    = false; // print prompt tokens before generation
     bool display_prompt    = true;  // print prompt before generation
-    bool dump_kv_cache     = false; // dump the KV cache contents for debugging purposes
     bool no_kv_offload     = false; // disable KV offloading
     bool warmup            = true;  // warmup run
     bool check_tensors     = false; // validate tensor data
+    bool no_op_offload     = false; // globally disable offload host tensor operations to device
 
     bool single_turn       = false; // single turn chat conversation
 
@@ -361,8 +346,10 @@ struct common_params {
 
     common_conversation_mode conversation_mode = COMMON_CONVERSATION_MODE_AUTO;
 
-    // multimodal models (see examples/llava)
-    std::string mmproj = "";        // path to multimodal projector                                         // NOLINT
+    // multimodal models (see tools/mtmd)
+    struct common_params_model mmproj;
+    bool mmproj_use_gpu = true;     // use GPU for multimodal model
+    bool no_mmproj = false;         // explicitly disable multimodal model
     std::vector<std::string> image; // path to image file(s)
 
     // embedding
@@ -385,6 +372,7 @@ struct common_params {
     bool use_jinja = false;                                                                                 // NOLINT
     bool enable_chat_template = true;
     common_reasoning_format reasoning_format = COMMON_REASONING_FORMAT_DEEPSEEK;
+    bool prefill_assistant = true;                                                                          // if true, any trailing assistant message will be prefilled into the response
 
     std::vector<std::string> api_keys;
 
@@ -428,13 +416,14 @@ struct common_params {
 
     bool process_output = false; // collect data for the output tensor
     bool compute_ppl    = true;  // whether to compute perplexity
+    bool parse_special  = false; // whether to parse special tokens during imatrix tokenization
 
     // cvector-generator params
     int n_pca_batch = 100;
     int n_pca_iterations = 1000;
     dimre_method cvector_dimre_method = DIMRE_METHOD_PCA;
-    std::string cvector_positive_file = "examples/cvector-generator/positive.txt";
-    std::string cvector_negative_file = "examples/cvector-generator/negative.txt";
+    std::string cvector_positive_file = "tools/cvector-generator/positive.txt";
+    std::string cvector_negative_file = "tools/cvector-generator/negative.txt";
 
     bool spm_infill = false; // suffix/prefix/middle pattern for infill
 
@@ -443,6 +432,11 @@ struct common_params {
 
     // common params
     std::string out_file; // output filename for all example programs
+    // optional callback for model loading progress and cancellation:
+    // called with a progress value between 0.0 and 1.0.
+    // return false from callback to abort model loading or true to continue
+    llama_progress_callback load_progress_callback = NULL;
+    void *                  load_progress_callback_user_data = NULL;
 };
 
 // call once at the start of a program if it uses libcommon
@@ -520,10 +514,9 @@ static bool string_starts_with(const std::string & str,
     return str.rfind(prefix, 0) == 0;
 }
 
-static bool string_ends_with(const std::string & str,
-                               const std::string & suffix) {  // While we wait for C++20's std::string::ends_with...
-    return str.size() >= suffix.size() && str.compare(str.size()-suffix.size(), suffix.size(), suffix) == 0;
-}
+// While we wait for C++20's std::string::ends_with...
+bool string_ends_with(const std::string_view & str, const std::string_view & suffix);
+size_t string_find_partial_stop(const std::string_view & str, const std::string_view & stop);
 
 bool string_parse_kv_override(const char * data, std::vector<llama_model_kv_override> & overrides);
 void string_process_escapes(std::string & input);
@@ -564,6 +557,8 @@ struct lm_ggml_threadpool_params lm_ggml_threadpool_params_from_cpu_params(const
 // clear LoRA adapters from context, then apply new list of adapters
 void common_set_adapter_lora(struct llama_context * ctx, std::vector<common_adapter_lora_info> & lora);
 
+std::string                   get_model_endpoint();
+
 //
 // Batch utils
 //
@@ -630,16 +625,6 @@ std::string common_detokenize(
         const std::vector<llama_token> & tokens,
                                   bool   special = true);
 
-//
-// KV cache utils
-//
-
-// Dump the KV cache view with the number of sequences per cell.
-void common_kv_cache_dump_view(const llama_kv_cache_view & view, int row_size = 80);
-
-// Dump the KV cache view showing individual sequences in each cell (long output).
-void common_kv_cache_dump_view_seqs(const llama_kv_cache_view & view, int row_size = 40);
-
 //
 // Embedding utils
 //
@@ -681,3 +666,9 @@ const char * const LLM_KV_SPLIT_COUNT         = "split.count";
 const char * const LLM_KV_SPLIT_TENSORS_COUNT = "split.tensors.count";
 
 }
+
+//
+// training utils
+//
+
+lm_ggml_opt_dataset_t common_opt_dataset_init(struct llama_context * ctx, const std::vector<llama_token> & tokens, int64_t stride);