llama_cpp 0.3.4 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35afb5cc65c290036ae7e45459eadc9b509f34f33a3f7708244cf47f1a38829f
-  data.tar.gz: 3301158526c63d9d2004e22bda0d1cc8025b4343d8d737df96260786531b074d
+  metadata.gz: 545786d4c9308ffe0f7e214a12427beaea0b26bec915ff84b16eed25ef1932a4
+  data.tar.gz: aaa0d4fc1710b13a26163306c8b51e423233c2f7e4b3d6127f94c9b6c4846f9c
 SHA512:
-  metadata.gz: b0a50f9f012f44f119a70790d3de07c7fcc64151246791e270e4ff9fc479a85a01c53cf2775945eba3145a3ba89da55a8d14891c6236cfeae16aed5ae455cf0d
-  data.tar.gz: ede388584e115ae93d509b6c15b288303c348f3cfe8ea46879a1b69e6c96be31a321edbb52cfbeb309a8fb456738f3f6b7cc1d3f71ce7addbd05b3a1e73d4755
+  metadata.gz: 12b3ac122fd7ea59b51e2d6ff905ed1a71cf8a8b3650a269d4a3793ae32a0149f6836a792c8f216d0fdb0c39aeb3b47914e73ffc74b574bbe686660e6be84ea1
+  data.tar.gz: 5056b95552f3434692a6c19653810d77bb28ddf9b28abd78712ccfb4ee4f7d836a5d54e283513fcfc617cc79ffa7bb9257d4ac2b6d96ec89158bf94acd4cec86

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [[0.3.6](https://github.com/yoshoku/llama_cpp.rb/compare/v0.3.5...v0.3.6)] - 2023-08-04
+
+- Bump bundled llama.cpp from master-1a94186 to master-468ea24.
+  - Add `mul_mat_q` option to ContextParams.
+
+## [[0.3.5](https://github.com/yoshoku/llama_cpp.rb/compare/v0.3.4...v0.3.5)] - 2023-07-29
+
+- Bump bundled llama.cpp from master-d924522 to master-1a94186.
+  - Add `GrammarElement` and `Grammar` classes.
+  - Add `sample_grammar` method to Context.
+  - Add `grammar_accept_token method` method to Context.
+
 ## [[0.3.4](https://github.com/yoshoku/llama_cpp.rb/compare/v0.3.3...v0.3.4)] - 2023-07-23
 
 - Bump bundled llama.cpp from master-32c5411 to master-d924522.

data/README.md

@@ -12,11 +12,27 @@ This gem is still under development and may undergo many changes in the future.
 
 Install the gem and add to the application's Gemfile by executing:
 
-    $ bundle add llama_cpp
+```sh
+$ bundle add llama_cpp
+```
 
 If bundler is not being used to manage dependencies, install the gem by executing:
 
-    $ gem install llama_cpp
+```sh
+$ gem install llama_cpp
+```
+
+There are several installation options for improving execution performance:
+
+```sh
+# use OpenBLAS
+$ gem install llama_cpp -- --with-openblas
+
+# use Metal on macOS
+$ gem install llama_cpp -- --with-metal
+```
+
+Those options are defined in [extconf.rb](https://github.com/yoshoku/llama_cpp.rb/blob/main/ext/llama_cpp/extconf.rb) by with_config method.
 
 ## Usage
 

data/ext/llama_cpp/extconf.rb

@@ -5,7 +5,7 @@ require 'fileutils'
 
 abort 'libstdc++ is not found.' unless have_library('stdc++')
 
-$srcs = %w[ggml.c llama.cpp llama_cpp.cpp]
+$srcs = %w[ggml.c ggml-alloc.c llama.cpp llama_cpp.cpp]
 $srcs << 'ggml-opencl.cpp' if with_config('clblast')
 $srcs << 'ggml-mpi.c' if with_config('mpi')
 $CFLAGS << ' -w -DNDEBUG'
@@ -85,6 +85,7 @@ if with_config('mpi')
   $CXXFLAGS << ' -DGGML_USE_MPI -Wno-cast-qual'
 end
 
+# @!visibility private
 UNAME_M = RbConfig::CONFIG['build_cpu'] || RbConfig::CONFIG['host_cpu'] || RbConfig::CONFIG['target_cpu']
 
 # rubocop:disable Layout/LineLength

data/ext/llama_cpp/llama_cpp.cpp

@@ -8,6 +8,8 @@ VALUE rb_cLLaMAContextParams;
 VALUE rb_cLLaMAModelQuantizeParams;
 VALUE rb_cLLaMATokenData;
 VALUE rb_cLLaMATokenDataArray;
+VALUE rb_cLLaMAGrammarElement;
+VALUE rb_cLLaMAGrammar;
 
 class LLaMATokenDataWrapper {
 public:
@@ -412,6 +414,8 @@ public:
     rb_define_method(rb_cLLaMAContextParams, "rope_freq_scale", RUBY_METHOD_FUNC(_llama_context_params_get_rope_freq_scale), 0);
     rb_define_method(rb_cLLaMAContextParams, "low_vram=", RUBY_METHOD_FUNC(_llama_context_params_set_low_vram), 1);
     rb_define_method(rb_cLLaMAContextParams, "low_vram", RUBY_METHOD_FUNC(_llama_context_params_get_low_vram), 0);
+    rb_define_method(rb_cLLaMAContextParams, "mul_mat_q=", RUBY_METHOD_FUNC(_llama_context_params_set_mul_mat_q), 1);
+    rb_define_method(rb_cLLaMAContextParams, "mul_mat_q", RUBY_METHOD_FUNC(_llama_context_params_get_mul_mat_q), 0);
     rb_define_method(rb_cLLaMAContextParams, "seed=", RUBY_METHOD_FUNC(_llama_context_params_set_seed), 1);
     rb_define_method(rb_cLLaMAContextParams, "seed", RUBY_METHOD_FUNC(_llama_context_params_get_seed), 0);
     rb_define_method(rb_cLLaMAContextParams, "f16_kv=", RUBY_METHOD_FUNC(_llama_context_params_set_f16_kv), 1);
@@ -525,7 +529,7 @@ private:
   // low_vram
   static VALUE _llama_context_params_set_low_vram(VALUE self, VALUE low_vram) {
     LLaMAContextParamsWrapper* ptr = get_llama_context_params(self);
-    ptr->params.low_vram = low_vram == Qtrue ? true : false;
+    ptr->params.low_vram = RTEST(low_vram) ? true : false;
     return ptr->params.low_vram ? Qtrue : Qfalse;
   }
 
@@ -534,6 +538,18 @@ private:
     return ptr->params.low_vram ? Qtrue : Qfalse;
   }
 
+  // mul_mat_q
+  static VALUE _llama_context_params_set_mul_mat_q(VALUE self, VALUE mul_mat_q) {
+    LLaMAContextParamsWrapper* ptr = get_llama_context_params(self);
+    ptr->params.mul_mat_q = RTEST(mul_mat_q) ? true : false;
+    return ptr->params.mul_mat_q ? Qtrue : Qfalse;
+  }
+
+  static VALUE _llama_context_params_get_mul_mat_q(VALUE self) {
+    LLaMAContextParamsWrapper* ptr = get_llama_context_params(self);
+    return ptr->params.mul_mat_q ? Qtrue : Qfalse;
+  }
+
   // seed
   static VALUE _llama_context_params_set_seed(VALUE self, VALUE seed) {
     LLaMAContextParamsWrapper* ptr = get_llama_context_params(self);
@@ -553,7 +569,7 @@ private:
   // f16_kv
   static VALUE _llama_context_params_set_f16_kv(VALUE self, VALUE f16_kv) {
     LLaMAContextParamsWrapper* ptr = get_llama_context_params(self);
-    ptr->params.f16_kv = f16_kv == Qtrue ? true : false;
+    ptr->params.f16_kv = RTEST(f16_kv) ? true : false;
     return ptr->params.f16_kv ? Qtrue : Qfalse;
   }
 
@@ -565,7 +581,7 @@ private:
   // logits_all
   static VALUE _llama_context_params_set_logits_all(VALUE self, VALUE logits_all) {
     LLaMAContextParamsWrapper* ptr = get_llama_context_params(self);
-    ptr->params.logits_all = logits_all == Qtrue ? true : false;
+    ptr->params.logits_all = RTEST(logits_all) ? true : false;
     return ptr->params.logits_all ? Qtrue : Qfalse;
   }
 
@@ -577,7 +593,7 @@ private:
   // vocab_only
   static VALUE _llama_context_params_set_vocab_only(VALUE self, VALUE vocab_only) {
     LLaMAContextParamsWrapper* ptr = get_llama_context_params(self);
-    ptr->params.vocab_only = vocab_only == Qtrue ? true : false;
+    ptr->params.vocab_only = RTEST(vocab_only) ? true : false;
     return ptr->params.vocab_only ? Qtrue : Qfalse;
   }
 
@@ -589,7 +605,7 @@ private:
   // use_mmap
   static VALUE _llama_context_params_set_use_mmap(VALUE self, VALUE use_mmap) {
     LLaMAContextParamsWrapper* ptr = get_llama_context_params(self);
-    ptr->params.use_mmap = use_mmap == Qtrue ? true : false;
+    ptr->params.use_mmap = RTEST(use_mmap) ? true : false;
     return ptr->params.use_mmap ? Qtrue : Qfalse;
   }
 
@@ -601,7 +617,7 @@ private:
   // use_mlock
   static VALUE _llama_context_params_set_use_mlock(VALUE self, VALUE use_mlock) {
     LLaMAContextParamsWrapper* ptr = get_llama_context_params(self);
-    ptr->params.use_mlock = use_mlock == Qtrue ? true : false;
+    ptr->params.use_mlock = RTEST(use_mlock) ? true : false;
     return ptr->params.use_mlock ? Qtrue : Qfalse;
   }
 
@@ -613,7 +629,7 @@ private:
   // embedding
   static VALUE _llama_context_params_set_embedding(VALUE self, VALUE embedding) {
     LLaMAContextParamsWrapper* ptr = get_llama_context_params(self);
-    ptr->params.embedding = embedding == Qtrue ? true : false;
+    ptr->params.embedding = RTEST(embedding) ? true : false;
     return ptr->params.embedding ? Qtrue : Qfalse;
   }
 
@@ -1057,6 +1073,222 @@ const rb_data_type_t RbLLaMAModel::llama_model_type = {
   RUBY_TYPED_FREE_IMMEDIATELY
 };
 
+class LLaMAGrammarElementWrapper {
+public:
+  llama_grammar_element element;
+
+  LLaMAGrammarElementWrapper() {
+    element.type = LLAMA_GRETYPE_END;
+    element.value = 0;
+  }
+
+  ~LLaMAGrammarElementWrapper() {}
+};
+
+class RbLLaMAGrammarElement {
+public:
+  static VALUE llama_grammar_element_alloc(VALUE self) {
+    LLaMAGrammarElementWrapper* ptr = (LLaMAGrammarElementWrapper*)ruby_xmalloc(sizeof(LLaMAGrammarElementWrapper));
+    new (ptr) LLaMAGrammarElementWrapper();
+    return TypedData_Wrap_Struct(self, &llama_grammar_element_type, ptr);
+  }
+
+  static void llama_grammar_element_free(void* ptr) {
+    ((LLaMAGrammarElementWrapper*)ptr)->~LLaMAGrammarElementWrapper();
+    ruby_xfree(ptr);
+  }
+
+  static size_t llama_grammar_element_size(const void* ptr) {
+    return sizeof(*((LLaMAGrammarElementWrapper*)ptr));
+  }
+
+  static LLaMAGrammarElementWrapper* get_llama_grammar_element(VALUE self) {
+    LLaMAGrammarElementWrapper* ptr;
+    TypedData_Get_Struct(self, LLaMAGrammarElementWrapper, &llama_grammar_element_type, ptr);
+    return ptr;
+  }
+
+  static void define_class(VALUE outer) {
+    rb_cLLaMAGrammarElement = rb_define_class_under(outer, "GrammarElement", rb_cObject);
+    rb_define_alloc_func(rb_cLLaMAGrammarElement, llama_grammar_element_alloc);
+    rb_define_method(rb_cLLaMAGrammarElement, "initialize", RUBY_METHOD_FUNC(_llama_grammar_element_init), -1);
+    rb_define_method(rb_cLLaMAGrammarElement, "type=", RUBY_METHOD_FUNC(_llama_grammar_element_set_type), 1);
+    rb_define_method(rb_cLLaMAGrammarElement, "type", RUBY_METHOD_FUNC(_llama_grammar_element_get_type), 0);
+    rb_define_method(rb_cLLaMAGrammarElement, "value=", RUBY_METHOD_FUNC(_llama_grammar_element_set_value), 1);
+    rb_define_method(rb_cLLaMAGrammarElement, "value", RUBY_METHOD_FUNC(_llama_grammar_element_get_value), 0);
+  }
+
+private:
+  static const rb_data_type_t llama_grammar_element_type;
+
+  static VALUE _llama_grammar_element_init(int argc, VALUE* argv, VALUE self) {
+    VALUE kw_args = Qnil;
+    ID kw_table[2] = { rb_intern("type"), rb_intern("value") };
+    VALUE kw_values[2] = { Qundef, Qundef };
+    VALUE arr = Qnil;
+    rb_scan_args(argc, argv, ":", &arr, &kw_args);
+    rb_get_kwargs(kw_args, kw_table, 0, 2, kw_values);
+
+    if (kw_values[0] != Qundef && !RB_INTEGER_TYPE_P(kw_values[0])) {
+      rb_raise(rb_eArgError, "type must be an integer");
+      return Qnil;
+    }
+    if (kw_values[1] != Qundef && !RB_INTEGER_TYPE_P(kw_values[1])) {
+      rb_raise(rb_eArgError, "value must be an integer");
+      return Qnil;
+    }
+
+    LLaMAGrammarElementWrapper* ptr = get_llama_grammar_element(self);
+    new (ptr) LLaMAGrammarElementWrapper();
+
+    if (kw_values[0] != Qundef) {
+      ptr->element.type = (enum llama_gretype)NUM2INT(kw_values[0]);
+    }
+    if (kw_values[1] != Qundef) {
+      ptr->element.value = NUM2INT(kw_values[1]);
+    }
+
+    return self;
+  }
+
+  // type
+  static VALUE _llama_grammar_element_set_type(VALUE self, VALUE type) {
+    LLaMAGrammarElementWrapper* ptr = get_llama_grammar_element(self);
+    ptr->element.type = (enum llama_gretype)NUM2INT(type);
+    return INT2NUM(ptr->element.type);
+  }
+
+  static VALUE _llama_grammar_element_get_type(VALUE self) {
+    LLaMAGrammarElementWrapper* ptr = get_llama_grammar_element(self);
+    return INT2NUM(ptr->element.type);
+  }
+
+  // value
+  static VALUE _llama_grammar_element_set_value(VALUE self, VALUE type) {
+    LLaMAGrammarElementWrapper* ptr = get_llama_grammar_element(self);
+    ptr->element.value = NUM2INT(type);
+    return INT2NUM(ptr->element.value);
+  }
+
+  static VALUE _llama_grammar_element_get_value(VALUE self) {
+    LLaMAGrammarElementWrapper* ptr = get_llama_grammar_element(self);
+    return INT2NUM(ptr->element.value);
+  }
+};
+
+const rb_data_type_t RbLLaMAGrammarElement::llama_grammar_element_type = {
+  "RbLLaMAGrammarElement",
+  { NULL,
+    RbLLaMAGrammarElement::llama_grammar_element_free,
+    RbLLaMAGrammarElement::llama_grammar_element_size },
+  NULL,
+  NULL,
+  RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+class LLaMAGrammarWrapper {
+public:
+  struct llama_grammar* grammar;
+
+  LLaMAGrammarWrapper() : grammar(nullptr) {}
+
+  ~LLaMAGrammarWrapper() {
+    if (grammar) {
+      llama_grammar_free(grammar);
+    }
+  }
+};
+
+class RbLLaMAGrammar {
+public:
+  static VALUE llama_grammar_alloc(VALUE self) {
+    LLaMAGrammarWrapper* ptr = (LLaMAGrammarWrapper*)ruby_xmalloc(sizeof(LLaMAGrammarWrapper));
+    new (ptr) LLaMAGrammarWrapper();
+    return TypedData_Wrap_Struct(self, &llama_grammar_type, ptr);
+  }
+
+  static void llama_grammar_free(void* ptr) {
+    ((LLaMAGrammarWrapper*)ptr)->~LLaMAGrammarWrapper();
+    ruby_xfree(ptr);
+  }
+
+  static size_t llama_grammar_size(const void* ptr) {
+    return sizeof(*((LLaMAGrammarWrapper*)ptr));
+  }
+
+  static LLaMAGrammarWrapper* get_llama_grammar(VALUE self) {
+    LLaMAGrammarWrapper* ptr;
+    TypedData_Get_Struct(self, LLaMAGrammarWrapper, &llama_grammar_type, ptr);
+    return ptr;
+  }
+
+  static void define_class(VALUE outer) {
+    rb_cLLaMAGrammar = rb_define_class_under(outer, "Grammar", rb_cObject);
+    rb_define_alloc_func(rb_cLLaMAGrammar, llama_grammar_alloc);
+    rb_define_method(rb_cLLaMAGrammar, "initialize", RUBY_METHOD_FUNC(_llama_grammar_init), -1);
+  }
+
+private:
+  static const rb_data_type_t llama_grammar_type;
+
+  static VALUE _llama_grammar_init(int argc, VALUE* argv, VALUE self) {
+    VALUE kw_args = Qnil;
+    ID kw_table[2] = { rb_intern("rules"), rb_intern("start_rule_index") };
+    VALUE kw_values[2] = { Qundef, Qundef };
+    rb_scan_args(argc, argv, ":", &kw_args);
+    rb_get_kwargs(kw_args, kw_table, 2, 0, kw_values);
+
+    if (!RB_TYPE_P(kw_values[0], T_ARRAY)) {
+      rb_raise(rb_eArgError, "rules must be an array");
+      return Qnil;
+    }
+    if (!RB_INTEGER_TYPE_P(kw_values[1])) {
+      rb_raise(rb_eArgError, "start_rule_index must be an integer");
+      return Qnil;
+    }
+
+    const int n_rules = RARRAY_LEN(kw_values[0]);
+    llama_grammar_element** rules = ALLOCA_N(llama_grammar_element*, n_rules);
+    for (int i = 0; i < n_rules; ++i) {
+      VALUE rule = rb_ary_entry(kw_values[0], i);
+      if (!RB_TYPE_P(rule, T_ARRAY)) {
+        rb_raise(rb_eArgError, "element of rules must be an array");
+        return Qnil;
+      }
+      const int n_elements = RARRAY_LEN(rule);
+      llama_grammar_element* elements = ALLOCA_N(llama_grammar_element, n_elements);
+      for (int j = 0; j < n_elements; ++j) {
+        VALUE element = rb_ary_entry(rule, j);
+        if (!rb_obj_is_kind_of(element, rb_cLLaMAGrammarElement)) {
+          rb_raise(rb_eArgError, "element of rule must be an instance of GrammarElement");
+          return Qnil;
+        }
+        LLaMAGrammarElementWrapper* ptr = RbLLaMAGrammarElement::get_llama_grammar_element(element);
+        elements[j] = ptr->element;
+      }
+      rules[i] = elements;
+    }
+
+    const size_t start_rule_index = NUM2SIZET(kw_values[1]);
+
+    LLaMAGrammarWrapper* ptr = get_llama_grammar(self);
+    new (ptr) LLaMAGrammarWrapper();
+    ptr->grammar = llama_grammar_init((const llama_grammar_element**)rules, n_rules, start_rule_index);
+
+    return self;
+  }
+};
+
+const rb_data_type_t RbLLaMAGrammar::llama_grammar_type = {
+  "RbLLaMAGrammar",
+  { NULL,
+    RbLLaMAGrammar::llama_grammar_free,
+    RbLLaMAGrammar::llama_grammar_size },
+  NULL,
+  NULL,
+  RUBY_TYPED_FREE_IMMEDIATELY
+};
+
 class LLaMAContextWrapper {
 public:
   struct llama_context* ctx;
@@ -1128,6 +1360,8 @@ public:
     rb_define_method(rb_cLLaMAContext, "sample_token_mirostat_v2", RUBY_METHOD_FUNC(_llama_context_sample_token_mirostat_v2), -1);
     rb_define_method(rb_cLLaMAContext, "sample_token_greedy", RUBY_METHOD_FUNC(_llama_context_sample_token_greedy), 1);
     rb_define_method(rb_cLLaMAContext, "sample_token", RUBY_METHOD_FUNC(_llama_context_sample_token), 1);
+    rb_define_method(rb_cLLaMAContext, "sample_grammar", RUBY_METHOD_FUNC(_llama_context_sample_grammar), -1);
+    rb_define_method(rb_cLLaMAContext, "grammar_accept_token", RUBY_METHOD_FUNC(_llama_context_grammar_accept_token), -1);
   }
 
 private:
@@ -2104,6 +2338,69 @@ private:
     llama_token id = llama_sample_token(ctx_ptr->ctx, &(cnd_ptr->array));
     return INT2NUM(id);
   }
+
+  static VALUE _llama_context_sample_grammar(int argc, VALUE* argv, VALUE self) {
+    VALUE kw_args = Qnil;
+    ID kw_table[1] = { rb_intern("grammar") };
+    VALUE kw_values[1] = { Qundef };
+    VALUE candidates = Qnil;
+    rb_scan_args(argc, argv, "1:", &candidates, &kw_args);
+    rb_get_kwargs(kw_args, kw_table, 1, 0, kw_values);
+
+    if (!rb_obj_is_kind_of(candidates, rb_cLLaMATokenDataArray)) {
+      rb_raise(rb_eArgError, "1st argument must be a TokenDataArray");
+      return Qnil;
+    }
+    if (!rb_obj_is_kind_of(kw_values[0], rb_cLLaMAGrammar)) {
+      rb_raise(rb_eArgError, "grammar must be a Grammar");
+      return Qnil;
+    }
+
+    LLaMAContextWrapper* ctx_ptr = get_llama_context(self);
+    if (ctx_ptr->ctx == NULL) {
+      rb_raise(rb_eRuntimeError, "LLaMA context is not initialized");
+      return Qnil;
+    }
+    LLaMATokenDataArrayWrapper* cnd_ptr = RbLLaMATokenDataArray::get_llama_token_data_array(candidates);
+    if (cnd_ptr->array.data == nullptr) {
+      rb_raise(rb_eRuntimeError, "TokenDataArray is empty");
+      return Qnil;
+    }
+    LLaMAGrammarWrapper* grm_ptr = RbLLaMAGrammar::get_llama_grammar(kw_values[0]);
+
+    llama_sample_grammar(ctx_ptr->ctx, &(cnd_ptr->array), grm_ptr->grammar);
+
+    return Qnil;
+  }
+
+  static VALUE _llama_context_grammar_accept_token(int argc, VALUE* argv, VALUE self) {
+    VALUE kw_args = Qnil;
+    ID kw_table[2] = { rb_intern("grammar"), rb_intern("token") };
+    VALUE kw_values[2] = { Qundef, Qundef };
+    rb_scan_args(argc, argv, ":", &kw_args);
+    rb_get_kwargs(kw_args, kw_table, 2, 0, kw_values);
+
+    if (!rb_obj_is_kind_of(kw_values[0], rb_cLLaMAGrammar)) {
+      rb_raise(rb_eArgError, "grammar must be a Grammar");
+      return Qnil;
+    }
+    if (!RB_INTEGER_TYPE_P(kw_values[1])) {
+      rb_raise(rb_eArgError, "token must be an Integer");
+      return Qnil;
+    }
+
+    LLaMAContextWrapper* ctx_ptr = get_llama_context(self);
+    if (ctx_ptr->ctx == NULL) {
+      rb_raise(rb_eRuntimeError, "LLaMA context is not initialized");
+      return Qnil;
+    }
+    LLaMAGrammarWrapper* grm_ptr = RbLLaMAGrammar::get_llama_grammar(kw_values[0]);
+    llama_token token = NUM2INT(kw_values[1]);
+
+    llama_grammar_accept_token(ctx_ptr->ctx, grm_ptr->grammar, token);
+
+    return Qnil;
+  }
 };
 
 const rb_data_type_t RbLLaMAContext::llama_context_type = {
@@ -2125,7 +2422,7 @@ static VALUE rb_llama_llama_backend_init(int argc, VALUE* argv, VALUE self) {
   rb_scan_args(argc, argv, ":", &kw_args);
   rb_get_kwargs(kw_args, kw_table, 0, 1, kw_values);
 
-  const bool numa = kw_values[0] == Qundef ? false : (RTEST ? true : false);
+  const bool numa = kw_values[0] == Qundef ? false : (RTEST(kw_values[0]) ? true : false);
   llama_backend_init(numa);
 
   return Qnil;
@@ -2208,6 +2505,8 @@ extern "C" void Init_llama_cpp(void) {
   RbLLaMAContext::define_class(rb_mLLaMACpp);
   RbLLaMAContextParams::define_class(rb_mLLaMACpp);
   RbLLaMAModelQuantizeParams::define_class(rb_mLLaMACpp);
+  RbLLaMAGrammarElement::define_class(rb_mLLaMACpp);
+  RbLLaMAGrammar::define_class(rb_mLLaMACpp);
 
   rb_define_module_function(rb_mLLaMACpp, "backend_init", rb_llama_llama_backend_init, -1);
   rb_define_module_function(rb_mLLaMACpp, "backend_free", rb_llama_llama_backend_free, 0);
@@ -2240,6 +2539,14 @@ extern "C" void Init_llama_cpp(void) {
   rb_define_const(rb_mLLaMACpp, "LLAMA_FTYPE_MOSTLY_Q5_K_M", INT2NUM(LLAMA_FTYPE_MOSTLY_Q5_K_M));
   rb_define_const(rb_mLLaMACpp, "LLAMA_FTYPE_MOSTLY_Q6_K", INT2NUM(LLAMA_FTYPE_MOSTLY_Q6_K));
 
+  rb_define_const(rb_mLLaMACpp, "LLAMA_GRETYPE_END", INT2NUM(LLAMA_GRETYPE_END));
+  rb_define_const(rb_mLLaMACpp, "LLAMA_GRETYPE_ALT", INT2NUM(LLAMA_GRETYPE_ALT));
+  rb_define_const(rb_mLLaMACpp, "LLAMA_GRETYPE_RULE_REF", INT2NUM(LLAMA_GRETYPE_RULE_REF));
+  rb_define_const(rb_mLLaMACpp, "LLAMA_GRETYPE_CHAR", INT2NUM(LLAMA_GRETYPE_CHAR));
+  rb_define_const(rb_mLLaMACpp, "LLAMA_GRETYPE_CHAR_NOT", INT2NUM(LLAMA_GRETYPE_CHAR_NOT));
+  rb_define_const(rb_mLLaMACpp, "LLAMA_GRETYPE_CHAR_RNG_UPPER", INT2NUM(LLAMA_GRETYPE_CHAR_RNG_UPPER));
+  rb_define_const(rb_mLLaMACpp, "LLAMA_GRETYPE_CHAR_ALT", INT2NUM(LLAMA_GRETYPE_CHAR_ALT));
+
   std::stringstream ss_magic;
   ss_magic << std::showbase << std::hex << LLAMA_FILE_MAGIC_GGJT;
   rb_define_const(rb_mLLaMACpp, "LLAMA_FILE_MAGIC_GGJT", rb_str_new2(ss_magic.str().c_str()));