whispercpp 1.3.5 → 1.3.7

data/ext/sources/examples/talk-llama/llama-hparams.cpp

@@ -1,241 +0,0 @@
-#include "llama-hparams.h"
-
-#include "ggml.h"
-
-#include <algorithm>
-#include <cassert>
-
-void llama_hparams::set_swa_pattern(uint32_t n_pattern, bool dense_first) {
-    if (dense_first) {
-        for (uint32_t il = 0; il < n_layer; ++il) {
-            swa_layers[il] = n_pattern == 0 || (il % n_pattern != 0);
-        }
-    } else {
-        for (uint32_t il = 0; il < n_layer; ++il) {
-            swa_layers[il] = n_pattern == 0 || (il % n_pattern < (n_pattern - 1));
-        }
-    }
-}
-
-bool llama_hparams::is_swa_any() const {
-    for (uint32_t il = 0; il < n_layer; ++il) {
-        if (swa_layers[il]) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-uint32_t llama_hparams::n_head(uint32_t il) const {
-    if (il < n_layer) {
-        return n_head_arr[il];
-    }
-
-    GGML_ABORT("fatal error");
-}
-
-uint32_t llama_hparams::n_head_kv(uint32_t il) const {
-    if (il < n_layer) {
-        return n_head_kv_arr[il];
-    }
-
-    GGML_ABORT("fatal error");
-}
-
-uint32_t llama_hparams::n_ff(uint32_t il) const {
-    if (il < n_layer) {
-        return n_ff_arr[il];
-    }
-
-    GGML_ABORT("fatal error");
-}
-
-uint32_t llama_hparams::n_gqa(uint32_t il) const {
-    const uint32_t n_head    = this->n_head(il);
-    const uint32_t n_head_kv = this->n_head_kv(il);
-
-    if (n_head_kv == 0) {
-        return 0;
-    }
-
-    return n_head/n_head_kv;
-}
-
-uint32_t llama_hparams::n_embd_inp() const {
-    uint32_t n_embd_inp = n_embd;
-
-    if (n_deepstack_layers > 0) {
-        n_embd_inp += n_embd * n_deepstack_layers;
-    }
-
-    return n_embd_inp;
-}
-
-uint32_t llama_hparams::get_n_embd_out() const {
-    return n_embd_out > 0 ? n_embd_out : n_embd;
-}
-
-uint32_t llama_hparams::n_embd_k_gqa(uint32_t il) const {
-    const uint32_t n_head_kv = this->n_head_kv(il);
-
-    return n_embd_head_k * n_head_kv;
-}
-
-uint32_t llama_hparams::n_embd_v_gqa(uint32_t il) const {
-    const uint32_t n_head_kv = this->n_head_kv(il);
-
-    return n_embd_head_v * n_head_kv;
-}
-
-bool llama_hparams::is_n_embd_k_gqa_variable() const {
-    const uint32_t val = n_embd_k_gqa();
-    for (uint32_t il = 0; il < n_layer; ++il) {
-        if (val != n_embd_k_gqa(il)) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-bool llama_hparams::is_n_embd_v_gqa_variable() const {
-    const uint32_t val = n_embd_v_gqa();
-    for (uint32_t il = 0; il < n_layer; ++il) {
-        if (val != n_embd_v_gqa(il)) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-uint32_t llama_hparams::n_embd_k_gqa_max() const {
-    uint32_t val = n_embd_k_gqa();
-    for (uint32_t il = 0; il < n_layer; ++il) {
-        val = std::max(val, n_embd_k_gqa(il));
-    }
-
-    return val;
-}
-
-uint32_t llama_hparams::n_embd_v_gqa_max() const {
-    uint32_t val = n_embd_v_gqa();
-    for (uint32_t il = 0; il < n_layer; ++il) {
-        val = std::max(val, n_embd_v_gqa(il));
-    }
-
-    return val;
-}
-
-uint32_t llama_hparams::n_embd_r() const {
-    if (wkv_head_size != 0) {
-        // for RWKV models
-        return token_shift_count * n_embd;
-    }
-
-    if (n_shortconv_l_cache != 0) {
-        // for LFM2 models
-        return n_embd * (n_shortconv_l_cache - 1);
-    }
-
-    // TODO: maybe support other convolution strides than 1
-    // NOTE: since the first column of the conv_state is shifted out each time, it's not actually needed
-    // Corresponds to Mamba's conv_states size
-    return (ssm_d_conv > 0 ? ssm_d_conv - 1 : 0) * (ssm_d_inner + 2*ssm_n_group*ssm_d_state);
-}
-
-uint32_t llama_hparams::n_embd_s() const {
-    if (wkv_head_size != 0) {
-        // corresponds to RWKV's wkv_states size
-        return n_embd * wkv_head_size;
-    }
-
-    // corresponds to Mamba's ssm_states size
-    return ssm_d_state * ssm_d_inner;
-}
-
-bool llama_hparams::is_recurrent(uint32_t il) const {
-    if (il < n_layer) {
-        return recurrent_layer_arr[il];
-    }
-
-    GGML_ABORT("%s: il (%u) out of bounds (n_layer: %u)\n", __func__, il, n_layer);
-}
-
-uint32_t llama_hparams::n_pos_per_embd() const {
-    return rope_type == LLAMA_ROPE_TYPE_MROPE || rope_type == LLAMA_ROPE_TYPE_IMROPE ? 4 : 1;
-}
-
-bool llama_hparams::is_swa(uint32_t il) const {
-    if (il < n_layer) {
-        return swa_layers[il];
-    }
-
-    GGML_ABORT("fatal error");
-}
-
-bool llama_hparams::has_kv(uint32_t il) const {
-    if (n_layer_kv_from_start >= 0) {
-        if (il < (uint32_t) n_layer_kv_from_start) {
-            return true;
-        }
-
-        return false;
-    }
-
-    // by default, all layers have kv
-    return true;
-}
-
-uint32_t llama_hparams::n_layer_kv() const {
-    uint32_t res = 0;
-
-    for (uint32_t il = 0; il < n_layer; ++il) {
-        if (has_kv(il)) {
-            res++;
-        }
-    }
-
-    return res;
-}
-
-bool llama_hparams::is_masked_swa(uint32_t n_swa, llama_swa_type swa_type, llama_pos p0, llama_pos p1) {
-    assert(p0 >= 0 && p1 >= 0);
-
-    switch (swa_type) {
-        case LLAMA_SWA_TYPE_NONE:
-            {
-            } break;
-        case LLAMA_SWA_TYPE_STANDARD:
-            {
-                if (p1 - p0 >= (int32_t) n_swa) {
-                    return true;
-                }
-            } break;
-        case LLAMA_SWA_TYPE_CHUNKED:
-            {
-                const llama_pos pos_chunk_start = (p1 / n_swa) * n_swa;
-
-                if (p0 < pos_chunk_start) {
-                    return true;
-                }
-            } break;
-        case LLAMA_SWA_TYPE_SYMMETRIC:
-            {
-                const int32_t half_n_swa = (int32_t) n_swa / 2;
-                const int32_t pos_diff = p1 - p0;
-
-                // Mask if outside the symmetric window
-                if (pos_diff < -half_n_swa || pos_diff > half_n_swa) {
-                    return true;
-                }
-            } break;
-    }
-
-    return false;
-}
-
-bool llama_hparams::use_mrope() const {
-    return rope_sections[0] > 0 && rope_sections[1] > 0;
-}

data/ext/sources/examples/talk-llama/llama-hparams.h

@@ -1,284 +0,0 @@
-#pragma once
-
-#include "llama.h"
-
-#include <array>
-
-// bump if necessary
-#define LLAMA_MAX_LAYERS  512
-#define LLAMA_MAX_EXPERTS 512 // Qwen3 Next
-
-enum llama_expert_gating_func_type {
-    LLAMA_EXPERT_GATING_FUNC_TYPE_NONE           = 0,
-    LLAMA_EXPERT_GATING_FUNC_TYPE_SOFTMAX        = 1,
-    LLAMA_EXPERT_GATING_FUNC_TYPE_SIGMOID        = 2,
-    LLAMA_EXPERT_GATING_FUNC_TYPE_SOFTMAX_WEIGHT = 3, // applied to the router weights instead of the logits
-};
-
-enum llama_swa_type {
-    LLAMA_SWA_TYPE_NONE      = 0,
-    LLAMA_SWA_TYPE_STANDARD  = 1,
-    LLAMA_SWA_TYPE_CHUNKED   = 2,
-    LLAMA_SWA_TYPE_SYMMETRIC = 3,
-};
-
-struct llama_hparams_posnet {
-    uint32_t n_embd;
-    uint32_t n_layer;
-};
-
-struct llama_hparams_convnext {
-    uint32_t n_embd;
-    uint32_t n_layer;
-};
-
-struct llama_hparams {
-    bool vocab_only;
-    bool no_alloc;
-    bool rope_finetuned;
-    bool use_par_res;
-    bool swin_norm;
-
-    uint32_t n_ctx_train; // context size the model was trained on
-    uint32_t n_embd;
-    uint32_t n_embd_features = 0;
-    uint32_t n_layer;
-    int32_t n_layer_kv_from_start = -1; // if non-negative, the first n_layer_kv_from_start layers have KV cache
-    uint32_t n_rot;
-    uint32_t n_embd_head_k; // dimension of keys (d_k). d_q is assumed to be the same, but there are n_head q heads, and only n_head_kv k-v heads
-    uint32_t n_embd_head_v; // dimension of values (d_v) aka n_embd_head
-    uint32_t n_expert = 0;
-    uint32_t n_expert_used = 0;
-    uint32_t n_rel_attn_bkts = 0;
-
-    // note: deepseek2 using MLA converts into MQA with larger heads, then decompresses to MHA
-    uint32_t n_embd_head_k_mla = 0;
-    uint32_t n_embd_head_v_mla = 0;
-
-    // for WavTokenizer
-    struct llama_hparams_posnet   posnet;
-    struct llama_hparams_convnext convnext;
-
-    uint32_t n_shortconv_l_cache  = 0;
-
-    std::array<uint32_t, LLAMA_MAX_LAYERS> n_head_arr;
-    std::array<uint32_t, LLAMA_MAX_LAYERS> n_head_kv_arr;
-    std::array<uint32_t, LLAMA_MAX_LAYERS> n_ff_arr;
-
-    uint32_t n_layer_dense_lead = 0;
-    uint32_t n_lora_q           = 0;
-    uint32_t n_lora_kv          = 0;
-    uint32_t n_ff_exp           = 0;
-    uint32_t n_ff_shexp         = 0;
-    uint32_t n_ff_chexp         = 0;
-    uint32_t n_expert_shared    = 0;
-    uint32_t n_norm_groups      = 0;
-    uint32_t n_expert_groups    = 0;
-    uint32_t n_group_used       = 0;
-    uint32_t n_group_experts    = 0;
-
-    float    expert_group_scale   = 0.05f;
-    float    expert_weights_scale = 0.0f;
-    bool     expert_weights_norm  = false;
-    uint32_t expert_gating_func   = LLAMA_EXPERT_GATING_FUNC_TYPE_NONE;
-    uint32_t moe_every_n_layers   = 0;
-    uint32_t nextn_predict_layers = 0;
-
-    float f_norm_eps;
-    float f_norm_rms_eps;
-    float f_norm_group_eps;
-
-    float f_attn_logit_softcapping   = 50.0f;
-    float f_router_logit_softcapping = 30.0f;
-    float f_final_logit_softcapping  = 30.0f;
-
-    // for RWKV
-    uint32_t rescale_every_n_layers = 0;
-    uint32_t time_mix_extra_dim     = 0;
-    uint32_t time_decay_extra_dim   = 0;
-    uint32_t wkv_head_size          = 0;
-    uint32_t token_shift_count      = 2;
-    uint32_t n_lora_decay           = 0;
-    uint32_t n_lora_iclr            = 0;
-    uint32_t n_lora_value_res_mix   = 0;
-    uint32_t n_lora_gate            = 0;
-
-    float    rope_attn_factor = 1.0f;
-    float    rope_freq_base_train;
-    float    rope_freq_base_train_swa  = 10000.0f;
-    float    rope_freq_scale_train;
-    float    rope_freq_scale_train_swa = 1.0f;
-
-    uint32_t n_ctx_orig_yarn;
-    float    rope_yarn_log_mul = 0.0f;
-
-    float    yarn_ext_factor  = -1.0f;
-    float    yarn_attn_factor =  1.0f;
-    float    yarn_beta_fast   = 32.0f;
-    float    yarn_beta_slow   =  1.0f;
-
-    std::array<int, 4> rope_sections;
-
-    // Sliding Window Attention (SWA)
-    llama_swa_type swa_type = LLAMA_SWA_TYPE_NONE;
-    // the size of the sliding window (0 - no SWA)
-    uint32_t n_swa = 0;
-    // if swa_layers[il] == 1, then layer il is SWA
-    // if swa_layers[il] == 0, then layer il is dense (i.e. non-SWA)
-    // by default, all layers are dense
-    // note: using uint32_t type for compatibility reason
-    std::array<uint32_t, LLAMA_MAX_LAYERS> swa_layers;
-
-    // for State Space Models
-    uint32_t ssm_d_conv  = 0;
-    uint32_t ssm_d_inner = 0;
-    uint32_t ssm_d_state = 0;
-    uint32_t ssm_dt_rank = 0;
-    uint32_t ssm_n_group = 0;
-
-    // for hybrid state space models
-    std::array<bool, LLAMA_MAX_LAYERS> recurrent_layer_arr;
-
-    bool ssm_dt_b_c_rms = false;
-
-    float f_clamp_kqv      = 0.0f;
-    float f_max_alibi_bias = 0.0f;
-    float f_logit_scale    = 0.0f;
-
-    // Additional scale factors (Granite/Granite MoE)
-    float f_residual_scale  = 0.0f;
-    float f_embedding_scale = 0.0f;
-    float f_attention_scale = 0.0f;
-
-    // grok-2
-    float    f_attn_out_scale = 0.0f;
-    uint32_t attn_temp_length = 0;
-
-    bool causal_attn   = true;
-    bool use_alibi     = false;
-    bool attn_soft_cap = false;
-    bool use_kq_norm   = false;
-
-    // for Classifiers
-    uint32_t n_cls_out = 1;
-
-    // output embedding dimension (0 = use n_embd)
-    uint32_t n_embd_out = 0;
-
-    // llama4 smallthinker
-    uint32_t n_moe_layer_step        = 0;
-    uint32_t n_no_rope_layer_step    = 4;
-    uint32_t n_attn_temp_floor_scale = 0;
-    float    f_attn_temp_scale       = 0.0f;
-    float    f_attn_temp_offset      = 0.0f; // offset position index
-
-    // gemma3n altup
-    uint32_t n_altup      = 4; // altup_num_inputs
-    uint32_t i_altup_act  = 0; // altup_active_idx
-    uint32_t laurel_rank  = 64;
-    uint32_t n_embd_altup = 256;
-
-    // needed for sentence-transformers dense layers
-    uint32_t dense_2_feat_in  = 0;  // in_features of the 2_Dense
-    uint32_t dense_2_feat_out = 0;  // out_features of the 2_Dense
-    uint32_t dense_3_feat_in  = 0;  // in_features of the 3_Dense
-    uint32_t dense_3_feat_out = 0;  // out_features of the 3_Dense
-
-    // xIELU
-    std::array<float, LLAMA_MAX_LAYERS> xielu_alpha_n;
-    std::array<float, LLAMA_MAX_LAYERS> xielu_alpha_p;
-    std::array<float, LLAMA_MAX_LAYERS> xielu_beta;
-    std::array<float, LLAMA_MAX_LAYERS> xielu_eps;
-
-    // qwen3vl deepstack
-    uint32_t n_deepstack_layers = 0;
-
-    // needed by encoder-decoder models (e.g. T5, FLAN-T5)
-    // ref: https://github.com/ggerganov/llama.cpp/pull/8141
-    llama_token dec_start_token_id = LLAMA_TOKEN_NULL;
-    uint32_t    dec_n_layer        = 0;
-
-    enum llama_pooling_type      pooling_type            = LLAMA_POOLING_TYPE_NONE;
-    enum llama_rope_type         rope_type               = LLAMA_ROPE_TYPE_NONE;
-    enum llama_rope_scaling_type rope_scaling_type_train = LLAMA_ROPE_SCALING_TYPE_NONE;
-
-    // this value n_pattern means that every nth layer is dense (i.e. non-SWA)
-    // dense_first means whether the pattern is start with a dense layer
-    // note that if n_pattern == 0, all layers are SWA
-    //           if n_pattern == 1, all layers are dense
-    // example 1: n_pattern = 3, dense_first = false
-    //   il == 0: swa
-    //   il == 1: swa
-    //   il == 2: dense
-    //   il == 3: swa
-    //   il == 4: swa
-    //   il == 5: dense
-    //   il == 6: swa
-    //   etc ...
-    // example 2: n_pattern = 2, dense_first = true
-    //   il == 0: dense
-    //   il == 1: swa
-    //   il == 2: dense
-    //   il == 3: swa
-    //   etc ...
-    void set_swa_pattern(uint32_t n_pattern, bool dense_first = false);
-
-    // return true if one of the layers is SWA
-    bool is_swa_any() const;
-
-    uint32_t n_head(uint32_t il = 0) const;
-
-    uint32_t n_head_kv(uint32_t il = 0) const;
-
-    uint32_t n_ff(uint32_t il = 0) const;
-
-    uint32_t n_gqa(uint32_t il = 0) const;
-
-    // dimension of main + auxiliary input embeddings
-    uint32_t n_embd_inp() const;
-
-    // dimension of output embeddings
-    uint32_t get_n_embd_out() const;
-
-    // dimension of key embeddings across all k-v heads
-    uint32_t n_embd_k_gqa(uint32_t il = 0) const;
-
-    // dimension of value embeddings across all k-v heads
-    uint32_t n_embd_v_gqa(uint32_t il = 0) const;
-
-    // true if any layer has a different n_embd_k_gqa/n_embd_v_gqa
-    bool is_n_embd_k_gqa_variable() const;
-    bool is_n_embd_v_gqa_variable() const;
-
-    // return the maximum n_embd_k_gqa/n_embd_v_gqa across all layers
-    uint32_t n_embd_k_gqa_max() const;
-    uint32_t n_embd_v_gqa_max() const;
-
-    // dimension of the rolling state embeddings
-    // corresponds to Mamba's conv_states size or RWKV's token_shift states size
-    uint32_t n_embd_r() const;
-
-    // dimension of the recurrent state embeddings
-    uint32_t n_embd_s() const;
-
-    // whether or not the given layer is recurrent (for hybrid models)
-    bool is_recurrent(uint32_t il) const;
-
-    uint32_t n_pos_per_embd() const;
-
-    bool is_swa(uint32_t il) const;
-
-    bool has_kv(uint32_t il) const;
-
-    // number of layers for which has_kv() returns true
-    uint32_t n_layer_kv() const;
-
-    // note that this function uses different SWA parameters from those in the hparams
-    // TODO: think of a better place for this function
-    // TODO: pack the SWA params in a struct?
-    static bool is_masked_swa(uint32_t n_swa, llama_swa_type swa_type, llama_pos p0, llama_pos p1);
-
-    bool use_mrope() const;
-};
-
-static_assert(std::is_trivially_copyable<llama_hparams>::value, "llama_hparams must be trivially copyable");

data/ext/sources/examples/talk-llama/llama-impl.cpp

@@ -1,171 +0,0 @@
-#include "llama-impl.h"
-
-#include "gguf.h"
-#include "llama.h"
-
-#include <cinttypes>
-#include <climits>
-#include <cstdarg>
-#include <cstring>
-#include <vector>
-#include <sstream>
-
-struct llama_logger_state {
-    ggml_log_callback log_callback = llama_log_callback_default;
-    void * log_callback_user_data = nullptr;
-};
-
-static llama_logger_state g_logger_state;
-
-time_meas::time_meas(int64_t & t_acc, bool disable) : t_start_us(disable ? -1 : ggml_time_us()), t_acc(t_acc) {}
-
-time_meas::~time_meas() {
-    if (t_start_us >= 0) {
-        t_acc += ggml_time_us() - t_start_us;
-    }
-}
-
-void llama_log_get(ggml_log_callback * log_callback, void ** user_data) {
-    ggml_log_get(log_callback, user_data);
-}
-
-void llama_log_set(ggml_log_callback log_callback, void * user_data) {
-    ggml_log_set(log_callback, user_data);
-    g_logger_state.log_callback = log_callback ? log_callback : llama_log_callback_default;
-    g_logger_state.log_callback_user_data = user_data;
-}
-
-static void llama_log_internal_v(ggml_log_level level, const char * format, va_list args) {
-    va_list args_copy;
-    va_copy(args_copy, args);
-    char buffer[128];
-    int len = vsnprintf(buffer, 128, format, args);
-    if (len < 128) {
-        g_logger_state.log_callback(level, buffer, g_logger_state.log_callback_user_data);
-    } else {
-        char * buffer2 = new char[len + 1];
-        vsnprintf(buffer2, len + 1, format, args_copy);
-        buffer2[len] = 0;
-        g_logger_state.log_callback(level, buffer2, g_logger_state.log_callback_user_data);
-        delete[] buffer2;
-    }
-    va_end(args_copy);
-}
-
-void llama_log_internal(ggml_log_level level, const char * format, ...) {
-    va_list args;
-    va_start(args, format);
-    llama_log_internal_v(level, format, args);
-    va_end(args);
-}
-
-void llama_log_callback_default(ggml_log_level level, const char * text, void * user_data) {
-    (void) level;
-    (void) user_data;
-    fputs(text, stderr);
-    fflush(stderr);
-}
-
-void replace_all(std::string & s, const std::string & search, const std::string & replace) {
-    if (search.empty()) {
-        return;
-    }
-    std::string builder;
-    builder.reserve(s.length());
-    size_t pos = 0;
-    size_t last_pos = 0;
-    while ((pos = s.find(search, last_pos)) != std::string::npos) {
-        builder.append(s, last_pos, pos - last_pos);
-        builder.append(replace);
-        last_pos = pos + search.length();
-    }
-    builder.append(s, last_pos, std::string::npos);
-    s = std::move(builder);
-}
-
-std::string format(const char * fmt, ...) {
-    va_list ap;
-    va_list ap2;
-    va_start(ap, fmt);
-    va_copy(ap2, ap);
-    int size = vsnprintf(NULL, 0, fmt, ap);
-    GGML_ASSERT(size >= 0 && size < INT_MAX); // NOLINT
-    std::vector<char> buf(size + 1);
-    int size2 = vsnprintf(buf.data(), size + 1, fmt, ap2);
-    GGML_ASSERT(size2 == size);
-    va_end(ap2);
-    va_end(ap);
-    return std::string(buf.data(), size);
-}
-
-std::string llama_format_tensor_shape(const std::vector<int64_t> & ne) {
-    char buf[256];
-    snprintf(buf, sizeof(buf), "%5" PRId64, ne.at(0));
-    for (size_t i = 1; i < ne.size(); i++) {
-        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), ", %5" PRId64, ne.at(i));
-    }
-    return buf;
-}
-
-std::string llama_format_tensor_shape(const struct ggml_tensor * t) {
-    char buf[256];
-    snprintf(buf, sizeof(buf), "%5" PRId64, t->ne[0]);
-    for (int i = 1; i < GGML_MAX_DIMS; i++) {
-        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), ", %5" PRId64, t->ne[i]);
-    }
-    return buf;
-}
-
-static std::string gguf_data_to_str(enum gguf_type type, const void * data, int i) {
-    switch (type) {
-        case GGUF_TYPE_UINT8:   return std::to_string(((const uint8_t  *)data)[i]);
-        case GGUF_TYPE_INT8:    return std::to_string(((const int8_t   *)data)[i]);
-        case GGUF_TYPE_UINT16:  return std::to_string(((const uint16_t *)data)[i]);
-        case GGUF_TYPE_INT16:   return std::to_string(((const int16_t  *)data)[i]);
-        case GGUF_TYPE_UINT32:  return std::to_string(((const uint32_t *)data)[i]);
-        case GGUF_TYPE_INT32:   return std::to_string(((const int32_t  *)data)[i]);
-        case GGUF_TYPE_UINT64:  return std::to_string(((const uint64_t *)data)[i]);
-        case GGUF_TYPE_INT64:   return std::to_string(((const int64_t  *)data)[i]);
-        case GGUF_TYPE_FLOAT32: return std::to_string(((const float    *)data)[i]);
-        case GGUF_TYPE_FLOAT64: return std::to_string(((const double   *)data)[i]);
-        case GGUF_TYPE_BOOL:    return ((const bool *)data)[i] ? "true" : "false";
-        default:                return format("unknown type %d", type);
-    }
-}
-
-std::string gguf_kv_to_str(const struct gguf_context * ctx_gguf, int i) {
-    const enum gguf_type type = gguf_get_kv_type(ctx_gguf, i);
-
-    switch (type) {
-        case GGUF_TYPE_STRING:
-            return gguf_get_val_str(ctx_gguf, i);
-        case GGUF_TYPE_ARRAY:
-            {
-                const enum gguf_type arr_type = gguf_get_arr_type(ctx_gguf, i);
-                int arr_n = gguf_get_arr_n(ctx_gguf, i);
-                const void * data = arr_type == GGUF_TYPE_STRING ? nullptr : gguf_get_arr_data(ctx_gguf, i);
-                std::stringstream ss;
-                ss << "[";
-                for (int j = 0; j < arr_n; j++) {
-                    if (arr_type == GGUF_TYPE_STRING) {
-                        std::string val = gguf_get_arr_str(ctx_gguf, i, j);
-                        // escape quotes
-                        replace_all(val, "\\", "\\\\");
-                        replace_all(val, "\"", "\\\"");
-                        ss << '"' << val << '"';
-                    } else if (arr_type == GGUF_TYPE_ARRAY) {
-                        ss << "???";
-                    } else {
-                        ss << gguf_data_to_str(arr_type, data, j);
-                    }
-                    if (j < arr_n - 1) {
-                        ss << ", ";
-                    }
-                }
-                ss << "]";
-                return ss.str();
-            }
-        default:
-            return gguf_data_to_str(type, gguf_get_val_data(ctx_gguf, i), 0);
-    }
-}