red-candle 1.6.0 → 1.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e67b3106c236e7f579cf3bdfdf56f0b5ae99e8b33bb9bf35cfe361c19bb0514
-  data.tar.gz: 573ae31fda25ebd4f22e7338a6a94fd48ce9d869959957acbc8d77e1ed83052c
+  metadata.gz: 00c0870d599db76ba556ab880f69219bc32d72698c3570cd308df3923b1332f9
+  data.tar.gz: bffbd02fa1fe11813a304ed16771e6a72ee01f85ccb445eb67c5da6bf696c670
 SHA512:
-  metadata.gz: 382e0ab840efe730184a7baa9f7438f43b10898d94fbea2648d92fbcf30a39ae9dcf48626dbf5a63e64263c2300d88555815c95820c4a6060eaa7b5f370deb9d
-  data.tar.gz: 00b15a30260ce226ef97c4e47a193ed557147377835472df552fde8de5f60c319ac4b8d7a1ef4f6a0408232c46776503b6f4b9a30bb46209df750ce3f47dd7e7
+  metadata.gz: c9ab39f01e4777c3d9906592cf62b8b1d2d03fd04be4ba82d8ddee837678ac477be88b1a0a48fa898e443f7469681e26f25297d4d310c39fb5222137d3b17d87
+  data.tar.gz: 22fe87f0fb64754a0a19bcc632dff72b0cc43838d73797aa991c961b65c9ecb7d9bd7aacbde51baf4063011081f4111a64f53726b51c87aca3e48214304e0119

data/README.md

@@ -434,12 +434,26 @@ embedding = model.embedding("Hi there!")
 
 Red-Candle includes support for cross-encoder reranking models, which can be used to reorder documents by relevance to a query. This is particularly useful for improving search results or implementing retrieval-augmented generation (RAG) systems.
 
+### Supported Models
+
+Red-Candle supports both **BERT** and **XLM-RoBERTa** reranker architectures. The model type is auto-detected from `config.json`.
+
+| Model | Architecture | Params | Notes |
+|-------|-------------|--------|-------|
+| `BAAI/bge-reranker-base` | XLM-RoBERTa | 278M | Recommended — strong quality, multilingual |
+| `BAAI/bge-reranker-large` | XLM-RoBERTa | 560M | Best quality, higher resource usage |
+| `BAAI/bge-reranker-v2-m3` | XLM-RoBERTa | 278M | Multilingual, very strong |
+| `cross-encoder/ms-marco-MiniLM-L-12-v2` | BERT | 33M | Lightweight, English only |
+
 ### Basic Usage
 
 ```ruby
 require 'candle'
 
-# Initialize the reranker with a cross-encoder model
+# Initialize the reranker (BGE reranker recommended for quality)
+reranker = Candle::Reranker.from_pretrained("BAAI/bge-reranker-base")
+
+# Or use the lighter BERT-based model
 reranker = Candle::Reranker.from_pretrained("cross-encoder/ms-marco-MiniLM-L-12-v2")
 
 # Or with custom max_length for truncation (default is 512)
@@ -528,7 +542,7 @@ results = reranker.rerank_with_pooling(query, documents, "cls")
 results = reranker.rerank_sigmoid_with_pooling(query, documents, "cls")
 ```
 
-Note: The default "pooler" method is recommended as it matches how cross-encoder models are trained. Other pooling methods may produce different ranking results.
+Note: Pooling methods only apply to BERT-based models. XLM-RoBERTa models (e.g., BGE rerankers) have a built-in classification head and ignore the `pooling_method` parameter. For BERT models, the default "pooler" method is recommended as it matches how cross-encoder models are trained.
 
 ### CUDA Support
 
@@ -546,11 +560,11 @@ Cross-encoder reranking models differ from bi-encoder embedding models:
 - **Bi-encoders** (like the embedding models above) encode queries and documents separately into dense vectors
 - **Cross-encoders** process the query and document together, allowing for more nuanced relevance scoring
 
-The reranker uses a BERT-based architecture that:
-1. Concatenates the query and document with special tokens: `[CLS] query [SEP] document [SEP]`
-2. Processes them jointly through BERT layers
-3. Applies a pooler layer (dense + tanh) to the [CLS] token
-4. Uses a classifier layer to produce a single relevance score
+The reranker concatenates the query and document with special tokens and processes them jointly through transformer layers to produce a single relevance score.
+
+**BERT models** (e.g., MiniLM): Use a pooler layer (dense + tanh) on the [CLS] token, then a classifier layer. Pooling method is configurable (`pooler`, `cls`, `mean`).
+
+**XLM-RoBERTa models** (e.g., BGE rerankers): Use a built-in classification head that returns logits directly. The `pooling_method` parameter is ignored — the model handles its own pooling internally.
 
 This joint processing allows cross-encoders to capture subtle semantic relationships between queries and documents, making them more accurate for reranking tasks, though at the cost of higher computational requirements.
 

data/ext/candle/src/ruby/reranker.rs

@@ -1,18 +1,59 @@
 use magnus::{function, method, prelude::*, Error, RModule, RArray, RHash, Ruby};
-use candle_transformers::models::bert::{BertModel, Config};
+use candle_transformers::models::bert::{BertModel, Config as BertConfig};
+use candle_transformers::models::xlm_roberta::{
+    XLMRobertaForSequenceClassification, Config as XLMRobertaConfig,
+};
+use candle_transformers::models::debertav2::{
+    DebertaV2Model, DebertaV2ContextPooler, Config as DebertaV2Config,
+};
+use candle_transformers::models::modernbert::{
+    ModernBert, Config as ModernBertConfig,
+};
+use candle_transformers::models::qwen3::{
+    ModelForCausalLM as Qwen3Model, Config as Qwen3Config,
+};
 use candle_core::{Device as CoreDevice, Tensor, IndexOp, DType};
 use candle_nn::{VarBuilder, Linear, Module, ops::sigmoid};
 use hf_hub::{api::sync::Api, Repo, RepoType};
 use tokenizers::{EncodeInput, Tokenizer};
+use std::cell::RefCell;
 use crate::ruby::{Device, Result};
 use crate::tokenizer::{TokenizerWrapper, loader::TokenizerLoader};
 
+enum RerankerModel {
+    Bert {
+        model: BertModel,
+        pooler: Linear,
+        classifier: Linear,
+    },
+    XLMRoberta {
+        model: XLMRobertaForSequenceClassification,
+        pad_token_id: u32,
+    },
+    DeBERTa {
+        model: DebertaV2Model,
+        pooler: DebertaV2ContextPooler,
+        classifier: Linear,
+        pad_token_id: u32,
+    },
+    ModernBert {
+        model: ModernBert,
+        head_dense: Linear,
+        head_norm: candle_nn::LayerNorm,
+        classifier: Linear,
+        pad_token_id: u32,
+    },
+    Qwen3 {
+        model: RefCell<Qwen3Model>,
+        yes_token_id: u32,
+        no_token_id: u32,
+    },
+}
+
 #[magnus::wrap(class = "Candle::Reranker", free_immediately, size)]
 pub struct Reranker {
-    model: BertModel,
+    model: RerankerModel,
     tokenizer: TokenizerWrapper,
-    pooler: Linear,
-    classifier: Linear,
     device: CoreDevice,
     model_id: String,
 }
@@ -28,7 +69,7 @@ impl Reranker {
         let ruby = Ruby::get().unwrap();
         let runtime_error = ruby.exception_runtime_error();
 
-        let result = (|| -> std::result::Result<(BertModel, TokenizerWrapper, Linear, Linear), Box<dyn std::error::Error + Send + Sync>> {
+        let result = (|| -> std::result::Result<(RerankerModel, TokenizerWrapper), Box<dyn std::error::Error + Send + Sync>> {
             let api = Api::new()?;
             let repo = api.repo(Repo::new(model_id.clone(), RepoType::Model));
 
@@ -37,9 +78,10 @@ impl Reranker {
             let tokenizer_filename = repo.get("tokenizer.json")?;
             let weights_filename = repo.get("model.safetensors")?;
 
-            // Load config
-            let config = std::fs::read_to_string(config_filename)?;
-            let config: Config = serde_json::from_str(&config)?;
+            // Read raw config to detect model type
+            let config_str = std::fs::read_to_string(&config_filename)?;
+            let raw_config: serde_json::Value = serde_json::from_str(&config_str)?;
+            let model_type = raw_config["model_type"].as_str().unwrap_or("bert");
 
             // Setup tokenizer with padding AND truncation
             let tokenizer = Tokenizer::from_file(tokenizer_filename)?;
@@ -51,21 +93,71 @@ impl Reranker {
                 VarBuilder::from_mmaped_safetensors(&[weights_filename], DType::F32, &device)?
             };
 
-            // Load BERT model
-            let model = BertModel::load(vb.pp("bert"), &config)?;
-
-            // Load pooler layer (dense + tanh activation)
-            let pooler = candle_nn::linear(config.hidden_size, config.hidden_size, vb.pp("bert.pooler.dense"))?;
-
-            // Load classifier layer for cross-encoder (single output score)
-            let classifier = candle_nn::linear(config.hidden_size, 1, vb.pp("classifier"))?;
+            let model = match model_type {
+                "xlm-roberta" => {
+                    let config: XLMRobertaConfig = serde_json::from_str(&config_str)?;
+                    let pad_token_id = config.pad_token_id;
+                    let model = XLMRobertaForSequenceClassification::new(1, &config, vb)?;
+                    RerankerModel::XLMRoberta { model, pad_token_id }
+                }
+                "deberta-v2" => {
+                    let config: DebertaV2Config = serde_json::from_str(&config_str)?;
+                    let pad_token_id = config.pad_token_id.unwrap_or(0) as u32;
+                    let model = DebertaV2Model::load(vb.pp("deberta"), &config)?;
+                    let pooler = DebertaV2ContextPooler::load(vb.clone(), &config)?;
+                    let pooler_hidden_size = config.pooler_hidden_size.unwrap_or(config.hidden_size);
+                    let num_labels = config.id2label.as_ref().map_or(1, |m| m.len());
+                    let classifier = candle_nn::linear(pooler_hidden_size, num_labels, vb.pp("classifier"))?;
+                    RerankerModel::DeBERTa { model, pooler, classifier, pad_token_id }
+                }
+                "qwen3" => {
+                    let config: Qwen3Config = serde_json::from_str(&config_str)?;
+                    let model = Qwen3Model::new(&config, vb)?;
+
+                    // Look up "yes" and "no" token IDs from the tokenizer
+                    let yes_token_id: u32 = tokenizer
+                        .encode("yes", false)
+                        .ok()
+                        .and_then(|enc| enc.get_ids().first().copied())
+                        .unwrap_or(9693);
+                    let no_token_id: u32 = tokenizer
+                        .encode("no", false)
+                        .ok()
+                        .and_then(|enc| enc.get_ids().first().copied())
+                        .unwrap_or(2152);
+
+                    RerankerModel::Qwen3 {
+                        model: RefCell::new(model),
+                        yes_token_id,
+                        no_token_id,
+                    }
+                }
+                "modernbert" => {
+                    let config: ModernBertConfig = serde_json::from_str(&config_str)?;
+                    let pad_token_id = config.pad_token_id;
+                    let model = ModernBert::load(vb.clone(), &config)?;
+                    // ModernBertHead::load is private, so load the head layers manually
+                    let head_vb = vb.pp("head");
+                    let head_dense = candle_nn::linear_no_bias(config.hidden_size, config.hidden_size, head_vb.pp("dense"))?;
+                    let head_norm = candle_nn::layer_norm_no_bias(config.hidden_size, config.layer_norm_eps, head_vb.pp("norm"))?;
+                    let classifier = candle_nn::linear(config.hidden_size, 1, vb.pp("classifier"))?;
+                    RerankerModel::ModernBert { model, head_dense, head_norm, classifier, pad_token_id }
+                }
+                _ => {
+                    let config: BertConfig = serde_json::from_str(&config_str)?;
+                    let model = BertModel::load(vb.pp("bert"), &config)?;
+                    let pooler = candle_nn::linear(config.hidden_size, config.hidden_size, vb.pp("bert.pooler.dense"))?;
+                    let classifier = candle_nn::linear(config.hidden_size, 1, vb.pp("classifier"))?;
+                    RerankerModel::Bert { model, pooler, classifier }
+                }
+            };
 
-            Ok((model, TokenizerWrapper::new(tokenizer), pooler, classifier))
+            Ok((model, TokenizerWrapper::new(tokenizer)))
         })();
 
         match result {
-            Ok((model, tokenizer, pooler, classifier)) => {
-                Ok(Self { model, tokenizer, pooler, classifier, device, model_id })
+            Ok((model, tokenizer)) => {
+                Ok(Self { model, tokenizer, device, model_id })
             }
             Err(e) => Err(Error::new(runtime_error, format!("Failed to load model: {}", e))),
         }
@@ -164,49 +256,161 @@ impl Reranker {
             .map_err(|e| Error::new(runtime_error, format!("Failed to create tensor: {}", e)))?;
         let token_type_ids = Tensor::new(token_type_ids, &self.device)
             .map_err(|e| Error::new(runtime_error, format!("Failed to create token type ids tensor: {}", e)))?;
-        let attention_mask = token_ids.ne(0u32)
-            .map_err(|e| Error::new(runtime_error, format!("Failed to create attention mask: {}", e)))?;
-
-        // Forward pass through BERT
-        let embeddings = self.model.forward(&token_ids, &token_type_ids, Some(&attention_mask))
-            .map_err(|e| Error::new(runtime_error, format!("Model forward pass failed: {}", e)))?;
-
-        // Apply pooling based on the specified method
-        let pooled_embeddings = match pooling_method.as_str() {
-            "pooler" => {
-                // Extract [CLS] token and apply pooler (dense + tanh)
-                let cls_embeddings = self.extract_cls_embeddings(&embeddings)?;
-                let pooled = self.pooler.forward(&cls_embeddings)
+
+        // Compute scores based on model type
+        let scores = match &self.model {
+            RerankerModel::Bert { model, pooler, classifier } => {
+                let attention_mask = token_ids.ne(0u32)
+                    .map_err(|e| Error::new(runtime_error, format!("Failed to create attention mask: {}", e)))?;
+
+                // Forward pass through BERT
+                let embeddings = model.forward(&token_ids, &token_type_ids, Some(&attention_mask))
+                    .map_err(|e| Error::new(runtime_error, format!("Model forward pass failed: {}", e)))?;
+
+                // Apply pooling based on the specified method
+                let pooled_embeddings = match pooling_method.as_str() {
+                    "pooler" => {
+                        let cls_embeddings = self.extract_cls_embeddings(&embeddings)?;
+                        let pooled = pooler.forward(&cls_embeddings)
+                            .map_err(|e| Error::new(runtime_error, format!("Pooler forward failed: {}", e)))?;
+                        pooled.tanh()
+                            .map_err(|e| Error::new(runtime_error, format!("Tanh activation failed: {}", e)))?
+                    },
+                    "cls" => {
+                        self.extract_cls_embeddings(&embeddings)?
+                    },
+                    "mean" => {
+                        let (_batch, seq_len, _hidden) = embeddings.dims3()
+                            .map_err(|e| Error::new(runtime_error, format!("Failed to get tensor dimensions: {}", e)))?;
+                        let sum = embeddings.sum(1)
+                            .map_err(|e| Error::new(runtime_error, format!("Failed to sum embeddings: {}", e)))?;
+                        (sum / (seq_len as f64))
+                            .map_err(|e| Error::new(runtime_error, format!("Failed to compute mean: {}", e)))?
+                    },
+                    _ => return Err(Error::new(runtime_error,
+                        format!("Unknown pooling method: {}. Use 'pooler', 'cls', or 'mean'", pooling_method)))
+                };
+
+                let pooled_embeddings = pooled_embeddings.contiguous()
+                    .map_err(|e| Error::new(runtime_error, format!("Failed to make pooled_embeddings contiguous: {}", e)))?;
+                let logits = classifier.forward(&pooled_embeddings)
+                    .map_err(|e| Error::new(runtime_error, format!("Classifier forward failed: {}", e)))?;
+                logits.squeeze(1)
+                    .map_err(|e| Error::new(runtime_error, format!("Failed to squeeze tensor: {}", e)))?
+            }
+            RerankerModel::XLMRoberta { model, pad_token_id } => {
+                let attention_mask = token_ids.ne(*pad_token_id)
+                    .map_err(|e| Error::new(runtime_error, format!("Failed to create attention mask: {}", e)))?;
+
+                // XLMRobertaForSequenceClassification returns logits directly
+                let logits = model.forward(&token_ids, &attention_mask, &token_type_ids)
+                    .map_err(|e| Error::new(runtime_error, format!("Model forward pass failed: {}", e)))?;
+                logits.squeeze(1)
+                    .map_err(|e| Error::new(runtime_error, format!("Failed to squeeze tensor: {}", e)))?
+            }
+            RerankerModel::DeBERTa { model, pooler, classifier, pad_token_id } => {
+                let attention_mask = token_ids.ne(*pad_token_id)
+                    .map_err(|e| Error::new(runtime_error, format!("Failed to create attention mask: {}", e)))?;
+
+                // Forward through DeBERTa encoder
+                let encoder_output = model.forward(&token_ids, Some(token_type_ids.clone()), Some(attention_mask))
+                    .map_err(|e| Error::new(runtime_error, format!("Model forward pass failed: {}", e)))?;
+
+                // Pool and classify
+                let pooled = pooler.forward(&encoder_output)
                     .map_err(|e| Error::new(runtime_error, format!("Pooler forward failed: {}", e)))?;
-                pooled.tanh()
-                    .map_err(|e| Error::new(runtime_error, format!("Tanh activation failed: {}", e)))?
-            },
-            "cls" => {
-                // Just use the [CLS] token embeddings directly (no pooler layer)
-                self.extract_cls_embeddings(&embeddings)?
-            },
-            "mean" => {
-                // Mean pooling across all tokens
-                let (_batch, seq_len, _hidden) = embeddings.dims3()
-                    .map_err(|e| Error::new(runtime_error, format!("Failed to get tensor dimensions: {}", e)))?;
-                let sum = embeddings.sum(1)
-                    .map_err(|e| Error::new(runtime_error, format!("Failed to sum embeddings: {}", e)))?;
-                (sum / (seq_len as f64))
-                    .map_err(|e| Error::new(runtime_error, format!("Failed to compute mean: {}", e)))?
-            },
-            _ => return Err(Error::new(runtime_error,
-                format!("Unknown pooling method: {}. Use 'pooler', 'cls', or 'mean'", pooling_method)))
+                let logits = classifier.forward(&pooled)
+                    .map_err(|e| Error::new(runtime_error, format!("Classifier forward failed: {}", e)))?;
+                logits.squeeze(1)
+                    .map_err(|e| Error::new(runtime_error, format!("Failed to squeeze tensor: {}", e)))?
+            }
+            RerankerModel::ModernBert { model, head_dense, head_norm, classifier, pad_token_id } => {
+                let attention_mask = token_ids.ne(*pad_token_id)
+                    .map_err(|e| Error::new(runtime_error, format!("Failed to create attention mask: {}", e)))?;
+                let attention_mask_f32 = attention_mask.to_dtype(DType::F32)
+                    .map_err(|e| Error::new(runtime_error, format!("Failed to convert attention mask: {}", e)))?;
+
+                // Forward through ModernBERT encoder
+                let encoder_output = model.forward(&token_ids, &attention_mask_f32)
+                    .map_err(|e| Error::new(runtime_error, format!("Model forward pass failed: {}", e)))?;
+
+                // CLS pooling, then head (dense + GELU + norm) + classifier
+                let cls = encoder_output.i((.., 0, ..))
+                    .map_err(|e| Error::new(runtime_error, format!("Failed to extract CLS: {}", e)))?
+                    .contiguous()
+                    .map_err(|e| Error::new(runtime_error, format!("Failed to make contiguous: {}", e)))?;
+                let hidden = head_dense.forward(&cls)
+                    .map_err(|e| Error::new(runtime_error, format!("Head dense failed: {}", e)))?;
+                let hidden = hidden.gelu_erf()
+                    .map_err(|e| Error::new(runtime_error, format!("GELU activation failed: {}", e)))?;
+                let hidden = head_norm.forward(&hidden)
+                    .map_err(|e| Error::new(runtime_error, format!("Head norm failed: {}", e)))?;
+                let logits = classifier.forward(&hidden)
+                    .map_err(|e| Error::new(runtime_error, format!("Classifier forward failed: {}", e)))?;
+                logits.squeeze(1)
+                    .map_err(|e| Error::new(runtime_error, format!("Failed to squeeze tensor: {}", e)))?
+            }
+            RerankerModel::Qwen3 { model, yes_token_id, no_token_id } => {
+                // Qwen3 reranker: decoder-based yes/no scoring
+                // Process each document individually (causal LM, not batch encoder)
+                let mut scores_vec: Vec<f32> = Vec::with_capacity(documents.len());
+                let mut model = model.borrow_mut();
+
+                for doc in &documents {
+                    // Build the Qwen3 reranker prompt
+                    let prompt = format!(
+                        "<|im_start|>system\nJudge whether the Document meets the requirements based on the Query and the Instruct provided. Note that the answer can only be \"yes\" or \"no\".<|im_end|>\n<|im_start|>user\n<Instruct>: Given a web search query, retrieve relevant passages that answer the query\n<Query>: {}\n<Document>: {}<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n",
+                        query, doc
+                    );
+
+                    // Tokenize the prompt
+                    let encoding = self.tokenizer.inner().encode(prompt.as_str(), false)
+                        .map_err(|e| Error::new(runtime_error, format!("Tokenization failed: {}", e)))?;
+                    let input_ids: Vec<u32> = encoding.get_ids().to_vec();
+
+                    // Clear KV cache for each document
+                    model.clear_kv_cache();
+
+                    // Forward pass — get logits for the last token position
+                    let input_tensor = Tensor::new(&input_ids[..], &self.device)
+                        .map_err(|e| Error::new(runtime_error, format!("Failed to create tensor: {}", e)))?
+                        .unsqueeze(0)
+                        .map_err(|e| Error::new(runtime_error, format!("Failed to unsqueeze: {}", e)))?;
+
+                    let logits = model.forward(&input_tensor, 0)
+                        .map_err(|e| Error::new(runtime_error, format!("Model forward pass failed: {}", e)))?;
+
+                    // logits shape: [1, 1, vocab_size] → flatten to [vocab_size]
+                    let logits = logits.flatten_all()
+                        .map_err(|e| Error::new(runtime_error, format!("Failed to flatten: {}", e)))?
+                        .to_dtype(DType::F32)
+                        .map_err(|e| Error::new(runtime_error, format!("Failed to convert dtype: {}", e)))?;
+
+                    // Extract yes/no logits and compute score
+                    let yes_logit: f32 = logits.i(*yes_token_id as usize)
+                        .map_err(|e| Error::new(runtime_error, format!("Failed to get yes logit: {}", e)))?
+                        .to_scalar()
+                        .map_err(|e| Error::new(runtime_error, format!("Failed to convert yes logit: {}", e)))?;
+                    let no_logit: f32 = logits.i(*no_token_id as usize)
+                        .map_err(|e| Error::new(runtime_error, format!("Failed to get no logit: {}", e)))?
+                        .to_scalar()
+                        .map_err(|e| Error::new(runtime_error, format!("Failed to convert no logit: {}", e)))?;
+
+                    // softmax over [yes, no] → P(yes)
+                    let max_logit = yes_logit.max(no_logit);
+                    let yes_exp = (yes_logit - max_logit).exp();
+                    let no_exp = (no_logit - max_logit).exp();
+                    let score = yes_exp / (yes_exp + no_exp);
+
+                    scores_vec.push(score);
+                }
+
+                // Build scores tensor for uniform handling below
+                Tensor::new(scores_vec.as_slice(), &self.device)
+                    .map_err(|e| Error::new(runtime_error, format!("Failed to create scores tensor: {}", e)))?
+            }
         };
 
-        // Apply classifier to get relevance scores (raw logits)
-        // Ensure tensor is contiguous before linear layer
-        let pooled_embeddings = pooled_embeddings.contiguous()
-            .map_err(|e| Error::new(runtime_error, format!("Failed to make pooled_embeddings contiguous: {}", e)))?;
-        let logits = self.classifier.forward(&pooled_embeddings)
-            .map_err(|e| Error::new(runtime_error, format!("Classifier forward failed: {}", e)))?;
-        let scores = logits.squeeze(1)
-            .map_err(|e| Error::new(runtime_error, format!("Failed to squeeze tensor: {}", e)))?;
-
         // Optionally apply sigmoid activation
         let scores = if apply_sigmoid {
             sigmoid(&scores)

data/lib/candle/version.rb

@@ -1,5 +1,5 @@
 # :nocov:
 module Candle
-  VERSION = "1.6.0"
+  VERSION = "1.6.1"
 end
 # :nocov:

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: red-candle
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.6.1
 platform: ruby
 authors:
 - Christopher Petersen