red-candle 1.1.0 → 1.1.2

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

@@ -83,6 +83,26 @@ impl ModelType {
     }
 }
 
+// Macro to extract parameters from Ruby hash to reduce boilerplate
+macro_rules! extract_param {
+    // Basic parameter extraction
+    ($kwargs:expr, $config:expr, $param:ident) => {
+        if let Some(value) = $kwargs.get(magnus::Symbol::new(stringify!($param))) {
+            if let Ok(v) = TryConvert::try_convert(value) {
+                $config.$param = v;
+            }
+        }
+    };
+    // Optional parameter extraction (wraps in Some)
+    ($kwargs:expr, $config:expr, $param:ident, optional) => {
+        if let Some(value) = $kwargs.get(magnus::Symbol::new(stringify!($param))) {
+            if let Ok(v) = TryConvert::try_convert(value) {
+                $config.$param = Some(v);
+            }
+        }
+    };
+}
+
 #[derive(Clone, Debug)]
 #[magnus::wrap(class = "Candle::GenerationConfig", mark, free_immediately)]
 pub struct GenerationConfig {
@@ -93,55 +113,20 @@ impl GenerationConfig {
     pub fn new(kwargs: RHash) -> Result<Self> {
         let mut config = RustGenerationConfig::default();
         
-        // Extract values from kwargs manually
-        if let Some(value) = kwargs.get(magnus::Symbol::new("max_length")) {
-            if let Ok(v) = TryConvert::try_convert(value) {
-                config.max_length = v;
-            }
-        }
-        
-        if let Some(value) = kwargs.get(magnus::Symbol::new("temperature")) {
-            if let Ok(v) = TryConvert::try_convert(value) {
-                config.temperature = v;
-            }
-        }
-        
-        if let Some(value) = kwargs.get(magnus::Symbol::new("top_p")) {
-            if let Ok(v) = TryConvert::try_convert(value) {
-                config.top_p = Some(v);
-            }
-        }
-        
-        if let Some(value) = kwargs.get(magnus::Symbol::new("top_k")) {
-            if let Ok(v) = TryConvert::try_convert(value) {
-                config.top_k = Some(v);
-            }
-        }
-        
-        if let Some(value) = kwargs.get(magnus::Symbol::new("repetition_penalty")) {
-            if let Ok(v) = TryConvert::try_convert(value) {
-                config.repetition_penalty = v;
-            }
-        }
-        
-        if let Some(value) = kwargs.get(magnus::Symbol::new("repetition_penalty_last_n")) {
-            if let Ok(v) = TryConvert::try_convert(value) {
-                config.repetition_penalty_last_n = v;
-            }
-        }
-        
-        if let Some(value) = kwargs.get(magnus::Symbol::new("seed")) {
-            if let Ok(v) = TryConvert::try_convert(value) {
-                config.seed = v;
-            }
-        }
-        
-        if let Some(value) = kwargs.get(magnus::Symbol::new("include_prompt")) {
-            if let Ok(v) = TryConvert::try_convert(value) {
-                config.include_prompt = v;
-            }
-        }
+        // Extract basic parameters using macro
+        extract_param!(kwargs, config, max_length);
+        extract_param!(kwargs, config, temperature);
+        extract_param!(kwargs, config, top_p, optional);
+        extract_param!(kwargs, config, top_k, optional);
+        extract_param!(kwargs, config, repetition_penalty);
+        extract_param!(kwargs, config, repetition_penalty_last_n);
+        extract_param!(kwargs, config, seed);
+        extract_param!(kwargs, config, include_prompt);
+        extract_param!(kwargs, config, debug_tokens);
+        extract_param!(kwargs, config, stop_on_constraint_satisfaction);
+        extract_param!(kwargs, config, stop_on_match);
         
+        // Handle special cases that need custom logic
         if let Some(value) = kwargs.get(magnus::Symbol::new("stop_sequences")) {
             if let Ok(arr) = <RArray as TryConvert>::try_convert(value) {
                 config.stop_sequences = arr
@@ -151,13 +136,6 @@ impl GenerationConfig {
             }
         }
         
-        if let Some(value) = kwargs.get(magnus::Symbol::new("debug_tokens")) {
-            if let Ok(v) = TryConvert::try_convert(value) {
-                config.debug_tokens = v;
-            }
-        }
-        
-        // Handle constraint parameter
         if let Some(value) = kwargs.get(magnus::Symbol::new("constraint")) {
             if let Ok(constraint) = <&StructuredConstraint as TryConvert>::try_convert(value) {
                 config.constraint = Some(Arc::clone(&constraint.index));
@@ -209,6 +187,15 @@ impl GenerationConfig {
     pub fn debug_tokens(&self) -> bool {
         self.inner.debug_tokens
     }
+    
+    pub fn stop_on_constraint_satisfaction(&self) -> bool {
+        self.inner.stop_on_constraint_satisfaction
+    }
+    
+    pub fn stop_on_match(&self) -> bool {
+        self.inner.stop_on_match
+    }
+    
     pub fn constraint(&self) -> Option<StructuredConstraint> {
         self.inner.constraint.as_ref().map(|c| StructuredConstraint {
             index: Arc::clone(c),
@@ -372,6 +359,42 @@ impl LLM {
             ModelType::QuantizedGGUF(m) => Ok(crate::ruby::tokenizer::Tokenizer(m.tokenizer().clone())),
         }
     }
+
+    /// Get the EOS token string for this model
+    pub fn eos_token(&self) -> Result<String> {
+        let (eos_token_id, tokenizer_clone) = {
+            let model = match self.model.lock() {
+                Ok(guard) => guard,
+                Err(poisoned) => poisoned.into_inner(),
+            };
+            let model_ref = model.borrow();
+            
+            // Get both EOS token ID and tokenizer clone in one lock scope
+            let eos_id = match &*model_ref {
+                ModelType::Mistral(m) => m.eos_token_id(),
+                ModelType::Llama(m) => m.eos_token_id(),
+                ModelType::Gemma(m) => m.eos_token_id(),
+                ModelType::Qwen(m) => m.eos_token_id(),
+                ModelType::Phi(m) => m.eos_token_id(),
+                ModelType::QuantizedGGUF(m) => m.eos_token_id(),
+            };
+            
+            let tokenizer = match &*model_ref {
+                ModelType::Mistral(m) => m.tokenizer().clone(),
+                ModelType::Llama(m) => m.tokenizer().clone(),
+                ModelType::Gemma(m) => m.tokenizer().clone(),
+                ModelType::Qwen(m) => m.tokenizer().clone(),
+                ModelType::Phi(m) => m.tokenizer().clone(),
+                ModelType::QuantizedGGUF(m) => m.tokenizer().clone(),
+            };
+            
+            (eos_id, tokenizer)
+        }; // Lock is released here
+        
+        // Convert ID to string using the tokenizer
+        let tokenizer_wrapper = crate::ruby::tokenizer::Tokenizer(tokenizer_clone);
+        tokenizer_wrapper.id_to_token(eos_token_id as i64)
+    }
     
     /// Clear the model's cache (e.g., KV cache for transformers)
     pub fn clear_cache(&self) -> Result<()> {
@@ -460,6 +483,8 @@ pub fn init_llm(rb_candle: RModule) -> Result<()> {
     rb_generation_config.define_method("stop_sequences", method!(GenerationConfig::stop_sequences, 0))?;
     rb_generation_config.define_method("include_prompt", method!(GenerationConfig::include_prompt, 0))?;
     rb_generation_config.define_method("debug_tokens", method!(GenerationConfig::debug_tokens, 0))?;
+    rb_generation_config.define_method("stop_on_constraint_satisfaction", method!(GenerationConfig::stop_on_constraint_satisfaction, 0))?;
+    rb_generation_config.define_method("stop_on_match", method!(GenerationConfig::stop_on_match, 0))?;
     rb_generation_config.define_method("constraint", method!(GenerationConfig::constraint, 0))?;
     
     let rb_llm = rb_candle.define_class("LLM", magnus::class::object())?;
@@ -469,6 +494,7 @@ pub fn init_llm(rb_candle: RModule) -> Result<()> {
     rb_llm.define_method("model_name", method!(LLM::model_name, 0))?;
     rb_llm.define_method("device", method!(LLM::device, 0))?;
     rb_llm.define_method("tokenizer", method!(LLM::tokenizer, 0))?;
+    rb_llm.define_method("eos_token", method!(LLM::eos_token, 0))?;
     rb_llm.define_method("clear_cache", method!(LLM::clear_cache, 0))?;
     rb_llm.define_method("apply_chat_template", method!(LLM::apply_chat_template, 1))?;
     

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

@@ -651,4 +651,5 @@ pub fn init(rb_candle: RModule) -> Result<()> {
     rb_tensor.define_method("to_s", method!(Tensor::__str__, 0))?;
     rb_tensor.define_method("inspect", method!(Tensor::__repr__, 0))?;
     Ok(())
-}
+}
+

data/ext/candle/src/tokenizer/mod.rs

@@ -100,4 +100,5 @@ impl TokenizerWrapper {
     pub fn inner_mut(&mut self) -> &mut Tokenizer {
         &mut self.tokenizer
     }
-}
+}
+

data/ext/candle/tests/device_tests.rs

@@ -0,0 +1,43 @@
+use candle_core::Device as CoreDevice;
+
+#[test]
+fn test_device_creation() {
+    // CPU device should always work
+    let cpu = CoreDevice::Cpu;
+    assert!(matches!(cpu, CoreDevice::Cpu));
+    
+    // Test device display
+    assert_eq!(format!("{:?}", cpu), "Cpu");
+}
+
+#[cfg(feature = "cuda")]
+#[test]
+#[ignore = "requires CUDA hardware"]
+fn test_cuda_device_creation() {
+    // This might fail if no CUDA device is available
+    match CoreDevice::new_cuda(0) {
+        Ok(device) => assert!(matches!(device, CoreDevice::Cuda(_))),
+        Err(_) => println!("No CUDA device available for testing"),
+    }
+}
+
+#[cfg(feature = "metal")] 
+#[test]
+#[ignore = "requires Metal hardware"]
+fn test_metal_device_creation() {
+    // This might fail if no Metal device is available
+    match CoreDevice::new_metal(0) {
+        Ok(device) => assert!(matches!(device, CoreDevice::Metal(_))),
+        Err(_) => println!("No Metal device available for testing"),
+    }
+}
+
+#[test]
+fn test_device_matching() {
+    let cpu1 = CoreDevice::Cpu;
+    let cpu2 = CoreDevice::Cpu;
+    
+    // Same device types should match
+    assert!(matches!(cpu1, CoreDevice::Cpu));
+    assert!(matches!(cpu2, CoreDevice::Cpu));
+}

data/ext/candle/tests/tensor_tests.rs

@@ -0,0 +1,162 @@
+use candle_core::{Tensor, Device, DType};
+
+#[test]
+fn test_tensor_creation() {
+    let device = Device::Cpu;
+    
+    // Test tensor creation from slice
+    let data = vec![1.0f32, 2.0, 3.0, 4.0];
+    let tensor = Tensor::new(&data[..], &device).unwrap();
+    assert_eq!(tensor.dims(), &[4]);
+    assert_eq!(tensor.dtype(), DType::F32);
+    
+    // Test zeros
+    let zeros = Tensor::zeros(&[2, 3], DType::F32, &device).unwrap();
+    assert_eq!(zeros.dims(), &[2, 3]);
+    
+    // Test ones
+    let ones = Tensor::ones(&[3, 2], DType::F32, &device).unwrap();
+    assert_eq!(ones.dims(), &[3, 2]);
+}
+
+#[test]
+fn test_tensor_arithmetic() {
+    let device = Device::Cpu;
+    
+    let a = Tensor::new(&[1.0f32, 2.0, 3.0], &device).unwrap();
+    let b = Tensor::new(&[4.0f32, 5.0, 6.0], &device).unwrap();
+    
+    // Addition
+    let sum = a.add(&b).unwrap();
+    let sum_vec: Vec<f32> = sum.to_vec1().unwrap();
+    assert_eq!(sum_vec, vec![5.0, 7.0, 9.0]);
+    
+    // Subtraction
+    let diff = a.sub(&b).unwrap();
+    let diff_vec: Vec<f32> = diff.to_vec1().unwrap();
+    assert_eq!(diff_vec, vec![-3.0, -3.0, -3.0]);
+    
+    // Multiplication
+    let prod = a.mul(&b).unwrap();
+    let prod_vec: Vec<f32> = prod.to_vec1().unwrap();
+    assert_eq!(prod_vec, vec![4.0, 10.0, 18.0]);
+}
+
+#[test]
+fn test_tensor_reshape() {
+    let device = Device::Cpu;
+    
+    let tensor = Tensor::new(&[1.0f32, 2.0, 3.0, 4.0, 5.0, 6.0], &device).unwrap();
+    
+    // Reshape to 2x3
+    let reshaped = tensor.reshape(&[2, 3]).unwrap();
+    assert_eq!(reshaped.dims(), &[2, 3]);
+    
+    // Reshape to 3x2
+    let reshaped = tensor.reshape(&[3, 2]).unwrap();
+    assert_eq!(reshaped.dims(), &[3, 2]);
+}
+
+#[test]
+fn test_tensor_transpose() {
+    let device = Device::Cpu;
+    
+    let tensor = Tensor::new(&[1.0f32, 2.0, 3.0, 4.0], &device)
+        .unwrap()
+        .reshape(&[2, 2])
+        .unwrap();
+    
+    let transposed = tensor.transpose(0, 1).unwrap();
+    assert_eq!(transposed.dims(), &[2, 2]);
+    
+    let values: Vec<f32> = transposed.flatten_all().unwrap().to_vec1().unwrap();
+    assert_eq!(values, vec![1.0, 3.0, 2.0, 4.0]);
+}
+
+#[test]
+fn test_tensor_reduction() {
+    let device = Device::Cpu;
+    
+    let tensor = Tensor::new(&[1.0f32, 2.0, 3.0, 4.0], &device).unwrap();
+    
+    // Sum
+    let sum = tensor.sum_all().unwrap();
+    let sum_val: f32 = sum.to_scalar().unwrap();
+    assert_eq!(sum_val, 10.0);
+    
+    // Mean
+    let mean = tensor.mean_all().unwrap();
+    let mean_val: f32 = mean.to_scalar().unwrap();
+    assert_eq!(mean_val, 2.5);
+}
+
+#[test]
+fn test_tensor_indexing() {
+    let device = Device::Cpu;
+    
+    let tensor = Tensor::new(&[10.0f32, 20.0, 30.0, 40.0], &device).unwrap();
+    
+    // Get element at index 0
+    let elem = tensor.get(0).unwrap();
+    let val: f32 = elem.to_scalar().unwrap();
+    assert_eq!(val, 10.0);
+    
+    // Get element at index 2
+    let elem = tensor.get(2).unwrap();
+    let val: f32 = elem.to_scalar().unwrap();
+    assert_eq!(val, 30.0);
+}
+
+#[test]
+fn test_tensor_matmul() {
+    let device = Device::Cpu;
+    
+    // 2x3 matrix
+    let a = Tensor::new(&[1.0f32, 2.0, 3.0, 4.0, 5.0, 6.0], &device)
+        .unwrap()
+        .reshape(&[2, 3])
+        .unwrap();
+    
+    // 3x2 matrix
+    let b = Tensor::new(&[7.0f32, 8.0, 9.0, 10.0, 11.0, 12.0], &device)
+        .unwrap()
+        .reshape(&[3, 2])
+        .unwrap();
+    
+    // Matrix multiplication
+    let result = a.matmul(&b).unwrap();
+    assert_eq!(result.dims(), &[2, 2]);
+    
+    let values: Vec<f32> = result.flatten_all().unwrap().to_vec1().unwrap();
+    // [1*7 + 2*9 + 3*11, 1*8 + 2*10 + 3*12, 4*7 + 5*9 + 6*11, 4*8 + 5*10 + 6*12]
+    // = [58, 64, 139, 154]
+    assert_eq!(values, vec![58.0, 64.0, 139.0, 154.0]);
+}
+
+#[test]
+fn test_tensor_where() {
+    let device = Device::Cpu;
+    
+    // Create a condition tensor where values > 0 are treated as true
+    let cond_values = Tensor::new(&[1.0f32, 0.0, 1.0], &device).unwrap();
+    let cond = cond_values.gt(&Tensor::zeros(cond_values.shape(), DType::F32, &device).unwrap()).unwrap();
+    
+    let on_true = Tensor::new(&[10.0f32, 20.0, 30.0], &device).unwrap();
+    let on_false = Tensor::new(&[100.0f32, 200.0, 300.0], &device).unwrap();
+    
+    let result = cond.where_cond(&on_true, &on_false).unwrap();
+    let values: Vec<f32> = result.to_vec1().unwrap();
+    assert_eq!(values, vec![10.0, 200.0, 30.0]);
+}
+
+#[test]
+fn test_tensor_narrow() {
+    let device = Device::Cpu;
+    
+    let tensor = Tensor::new(&[1.0f32, 2.0, 3.0, 4.0, 5.0], &device).unwrap();
+    
+    // Narrow from index 1, length 3
+    let narrowed = tensor.narrow(0, 1, 3).unwrap();
+    let values: Vec<f32> = narrowed.to_vec1().unwrap();
+    assert_eq!(values, vec![2.0, 3.0, 4.0]);
+}

data/lib/candle/llm.rb

@@ -2,6 +2,35 @@ require 'json'
 
 module Candle
   class LLM
+    # Cache for EOS token to avoid repeated calls
+    def cached_eos_token
+      @cached_eos_token ||= begin
+        if respond_to?(:eos_token)
+          eos_token rescue nil
+        end
+      end
+    end
+    
+    # Get model-specific EOS tokens
+    def model_eos_tokens
+      @model_eos_tokens ||= begin
+        tokens = []
+        if model_eos = cached_eos_token
+          tokens << model_eos
+          # For Gemma, also include end_of_turn for chat scenarios and </s>
+          # Even though </s> is technically an HTML tag in Gemma's vocabulary,
+          # it seems to use it as a generation boundary in practice
+          if model_name.downcase.include?("gemma")
+            tokens << "<end_of_turn>"
+            tokens << "</s>"
+          end
+        else
+          # Fallback to common tokens only if model doesn't provide one
+          tokens = ["</s>", "<|endoftext|>", "<|im_end|>", "<end>"]
+        end
+        tokens.uniq
+      end
+    end
     # Create a structured constraint from a JSON schema
     def constraint_from_schema(schema)
       schema_str = schema.is_a?(String) ? schema : JSON.generate(schema)
@@ -15,48 +44,39 @@ module Candle
     end
     
     # Generate with regex constraint
-    def generate_regex(prompt, pattern:, **options)
+    def generate_regex(prompt, pattern:, stop_on_match: true, **options)
       constraint = constraint_from_regex(pattern)
       
-      # Add common EOS tokens as stop sequences for regex generation
-      stop_sequences = options[:stop_sequences] || []
-      stop_sequences += ["</s>", "<|endoftext|>", "<|im_end|>", "<end>", "\n"] unless options[:no_auto_stop]
-      
-      config_opts = options.merge(constraint: constraint, stop_sequences: stop_sequences)
+      # Configure generation with early stopping by default
+      config_opts = options.merge(
+        constraint: constraint,
+        stop_on_constraint_satisfaction: options.fetch(:stop_on_constraint_satisfaction, stop_on_match),
+        stop_on_match: stop_on_match
+      )
       config = options[:config] || GenerationConfig.balanced(**config_opts)
       
-      result = generate(prompt, config: config, reset_cache: options.fetch(:reset_cache, true))
-      
-      # Clean up any trailing EOS tokens
-      result.gsub(/(<\/s>|<\|endoftext\|>|<\|im_end\|>|<end>).*$/m, '').strip
+      generate(prompt, config: config, reset_cache: options.fetch(:reset_cache, true))
     end
     
     # Generate and parse structured output from a JSON schema
     def generate_structured(prompt, schema:, **options)
       constraint = constraint_from_schema(schema)
-      config_opts = options.merge(constraint: constraint)
+      
+      # Configure generation with early stopping by default
+      config_opts = options.merge(
+        constraint: constraint,
+        stop_on_constraint_satisfaction: options.fetch(:stop_on_constraint_satisfaction, true)
+      )
       config = options[:config] || GenerationConfig.balanced(**config_opts)
       
       result = generate(prompt, config: config, reset_cache: options.fetch(:reset_cache, true))
       
-      # Clean up the result - remove common end-of-sequence tokens
-      # that might appear after valid JSON
-      cleaned_result = result.gsub(/(<\/s>|<\|endoftext\|>|<\|im_end\|>|<end>).*$/m, '')
-      
       # Try to parse as JSON
       begin
-        JSON.parse(cleaned_result)
+        # First, try to extract JSON if there's content after stop tokens
+        json_content = extract_json_content(result)
+        JSON.parse(json_content)
       rescue JSON::ParserError => e
-        # If cleaning didn't help, try to extract JSON from the result
-        # Look for the first complete JSON object/array
-        if match = cleaned_result.match(/(\{[^{}]*\}|\[[^\[\]]*\])/m)
-          begin
-            return JSON.parse(match[1])
-          rescue JSON::ParserError
-            # Fall through to warning
-          end
-        end
-        
         # Return the raw string if parsing fails
         warn "Warning: Generated output is not valid JSON: #{e.message}" if options[:warn_on_parse_error]
         result
@@ -172,14 +192,7 @@ module Candle
 
     def generate(prompt, config: GenerationConfig.balanced, reset_cache: true)
       begin
-        result = _generate(prompt, config)
-        
-        # If there's a constraint, clean up common EOS tokens that appear after the constrained content
-        if config.constraint
-          result = result.gsub(/(<\/s>|<\|endoftext\|>|<\|im_end\|>|<end>).*$/m, '').strip
-        end
-        
-        result
+        _generate(prompt, config)
       ensure
         clear_cache if reset_cache
       end
@@ -228,6 +241,88 @@ module Candle
 
     private
 
+    # Extract JSON content from generated text, handling stop tokens and extra content
+    def extract_json_content(text)
+      # Remove any content after common stop tokens
+      cleaned = text
+      
+      # Check for EOS tokens and truncate at the first one found
+      model_eos_tokens.each do |token|
+        if idx = cleaned.index(token)
+          cleaned = cleaned[0...idx]
+        end
+      end
+      
+      # Try to find valid JSON boundaries
+      # First try a simple approach - find the first { or [ and match to its closing } or ]
+      start_idx = cleaned.index(/[\{\[]/)
+      return cleaned.strip unless start_idx
+      
+      # Extract from the start position
+      json_candidate = cleaned[start_idx..-1]
+      
+      # Try to find a valid JSON object or array
+      # This regex handles nested structures better
+      if json_candidate[0] == '{'
+        # Match a JSON object
+        bracket_count = 0
+        in_string = false
+        escape_next = false
+        
+        json_candidate.chars.each_with_index do |char, idx|
+          if !in_string
+            case char
+            when '{'
+              bracket_count += 1
+            when '}'
+              bracket_count -= 1
+              if bracket_count == 0
+                return json_candidate[0..idx]
+              end
+            when '"'
+              in_string = true unless escape_next
+            end
+          else
+            if char == '"' && !escape_next
+              in_string = false
+            end
+          end
+          
+          escape_next = (!escape_next && char == '\\')
+        end
+      elsif json_candidate[0] == '['
+        # Match a JSON array (similar logic)
+        bracket_count = 0
+        in_string = false
+        escape_next = false
+        
+        json_candidate.chars.each_with_index do |char, idx|
+          if !in_string
+            case char
+            when '['
+              bracket_count += 1
+            when ']'
+              bracket_count -= 1
+              if bracket_count == 0
+                return json_candidate[0..idx]
+              end
+            when '"'
+              in_string = true unless escape_next
+            end
+          else
+            if char == '"' && !escape_next
+              in_string = false
+            end
+          end
+          
+          escape_next = (!escape_next && char == '\\')
+        end
+      end
+      
+      # If no valid JSON structure found, return the cleaned string
+      cleaned.strip
+    end
+
     # Legacy format messages method - kept for backward compatibility
     # Use apply_chat_template for proper model-specific formatting
     def format_messages(messages)

data/lib/candle/version.rb

@@ -1,5 +1,5 @@
 # :nocov:
 module Candle
-  VERSION = "1.1.0"
+  VERSION = "1.1.2"
 end
 # :nocov:

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: red-candle
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.2
 platform: ruby
 authors:
 - Christopher Petersen
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-07-27 00:00:00.000000000 Z
+date: 2025-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -196,6 +196,8 @@ files:
 - ext/candle/target/release/build/clang-sys-cac31d63c4694603/out/macros.rs
 - ext/candle/target/release/build/pulp-1b95cfe377eede97/out/x86_64_asm.rs
 - ext/candle/target/release/build/rb-sys-f8ac4edc30ab3e53/out/bindings-0.9.116-mri-arm64-darwin24-3.3.0.rs
+- ext/candle/tests/device_tests.rs
+- ext/candle/tests/tensor_tests.rs
 - lib/candle.rb
 - lib/candle/build_info.rb
 - lib/candle/device_utils.rb