ruby_llm-red_candle 0.1.0

data/examples/smoke_test.rb

@@ -0,0 +1,320 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Smoke test for RubyLLM::RedCandle
+# Run with: bundle exec ruby examples/smoke_test.rb
+#
+# This script demonstrates all the features documented in the README.
+# It uses TinyLlama by default as it's the fastest model to download and run.
+
+require "bundler/setup"
+require "ruby_llm"
+require "ruby_llm-red_candle"
+
+# Configuration
+MODEL = ENV.fetch("SMOKE_TEST_MODEL", "TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF")
+SKIP_SLOW = ENV.fetch("SKIP_SLOW", nil) # Set to skip multi-turn and streaming tests
+
+# Helper for printing section headers
+def section(title)
+  puts
+  puts "=" * 60
+  puts " #{title}"
+  puts "=" * 60
+  puts
+end
+
+# Helper for printing test results
+def result(label, value)
+  puts "  #{label}: #{value}"
+end
+
+def success(message)
+  puts "  [OK] #{message}"
+end
+
+def info(message)
+  puts "  [INFO] #{message}"
+end
+
+begin
+  section "RubyLLM::RedCandle Smoke Test"
+  info "Model: #{MODEL}"
+  info "Ruby: #{RUBY_VERSION}"
+  info "RubyLLM: #{RubyLLM::VERSION}"
+  info "RedCandle: #{RubyLLM::RedCandle::VERSION}"
+
+  # ---------------------------------------------------------------------------
+  section "1. Listing Available Models"
+  # ---------------------------------------------------------------------------
+
+  models = RubyLLM.models.all.select { |m| m.provider == "red_candle" }
+  puts "  Available Red Candle models:"
+  models.each do |m|
+    puts "    - #{m.id} (#{m.context_window} tokens)"
+  end
+  success "Found #{models.size} models"
+
+  # ---------------------------------------------------------------------------
+  section "2. Basic Chat (Non-Streaming)"
+  # ---------------------------------------------------------------------------
+
+  info "Creating chat instance..."
+  chat = RubyLLM.chat(provider: :red_candle, model: MODEL)
+  success "Chat created"
+
+  info "Asking: 'What is 2 + 2?'"
+  response = chat.ask("What is 2 + 2? Answer with just the number.")
+
+  result "Response", response.content.strip
+  result "Input tokens (estimated)", response.input_tokens
+  result "Output tokens (estimated)", response.output_tokens
+  success "Basic chat completed"
+
+  # ---------------------------------------------------------------------------
+  section "3. Multi-Turn Conversation"
+  # ---------------------------------------------------------------------------
+
+  unless SKIP_SLOW
+    info "Creating new chat for multi-turn..."
+    chat = RubyLLM.chat(provider: :red_candle, model: MODEL)
+
+    info "Turn 1: 'My name is Alice.'"
+    chat.ask("My name is Alice.")
+
+    info "Turn 2: 'I love programming in Ruby.'"
+    chat.ask("I love programming in Ruby.")
+
+    info "Turn 3: 'What is my name and what do I love?'"
+    response = chat.ask("What is my name and what do I love? Be brief.")
+
+    result "Response", response.content.strip[0..200]
+    success "Multi-turn conversation completed"
+  else
+    info "Skipped (SKIP_SLOW is set)"
+  end
+
+  # ---------------------------------------------------------------------------
+  section "4. Streaming Output"
+  # ---------------------------------------------------------------------------
+
+  unless SKIP_SLOW
+    info "Creating chat for streaming..."
+    chat = RubyLLM.chat(provider: :red_candle, model: MODEL)
+
+    info "Streaming response for: 'Count from 1 to 5'"
+    print "  Response: "
+
+    chunks = []
+    chat.ask("Count from 1 to 5, just list the numbers.") do |chunk|
+      print chunk.content
+      $stdout.flush
+      chunks << chunk
+    end
+    puts
+
+    result "Chunks received", chunks.size
+    success "Streaming completed"
+  else
+    info "Skipped (SKIP_SLOW is set)"
+  end
+
+  # ---------------------------------------------------------------------------
+  section "5. Temperature Control"
+  # ---------------------------------------------------------------------------
+
+  info "Testing low temperature (0.1) - more deterministic..."
+  chat = RubyLLM.chat(provider: :red_candle, model: MODEL)
+  response = chat.with_temperature(0.1).ask("What is the capital of France? One word answer.")
+  result "Low temp response", response.content.strip
+
+  info "Testing high temperature (1.5) - more creative..."
+  response = chat.with_temperature(1.5).ask("Say something creative about the moon in 10 words or less.")
+  result "High temp response", response.content.strip
+
+  success "Temperature control completed"
+
+  # ---------------------------------------------------------------------------
+  section "6. System Prompts (Instructions)"
+  # ---------------------------------------------------------------------------
+
+  info "Setting system prompt for a pirate assistant..."
+  chat = RubyLLM.chat(provider: :red_candle, model: MODEL)
+  chat.with_instructions("You are a pirate. Always respond like a pirate would, using pirate slang.")
+
+  response = chat.ask("Hello, how are you today?")
+  result "Pirate response", response.content.strip[0..150]
+  success "System prompts completed"
+
+  # ---------------------------------------------------------------------------
+  section "7. Structured Output (JSON Schema)"
+  # ---------------------------------------------------------------------------
+
+  info "Defining schema for person profile..."
+  schema = {
+    type: "object",
+    properties: {
+      name: { type: "string" },
+      age: { type: "integer" },
+      occupation: { type: "string" }
+    },
+    required: %w[name age occupation]
+  }
+
+  info "Generating structured output..."
+  chat = RubyLLM.chat(provider: :red_candle, model: MODEL)
+  response = chat.with_schema(schema).ask("Generate a profile for a 28-year-old teacher named Bob")
+
+  result "Response type", response.content.class
+  result "Response", response.content.inspect
+
+  if response.content.is_a?(Hash)
+    result "Name", response.content["name"]
+    result "Age", response.content["age"]
+    result "Occupation", response.content["occupation"]
+    success "Structured output returned a Hash"
+  else
+    info "Response was a String (may indicate parse issue): #{response.content}"
+  end
+
+  # ---------------------------------------------------------------------------
+  section "8. Structured Output with Enums"
+  # ---------------------------------------------------------------------------
+
+  info "Defining schema with enum constraint..."
+  sentiment_schema = {
+    type: "object",
+    properties: {
+      sentiment: {
+        type: "string",
+        enum: %w[positive negative neutral]
+      },
+      confidence: { type: "number" }
+    },
+    required: %w[sentiment confidence]
+  }
+
+  info "Analyzing sentiment..."
+  chat = RubyLLM.chat(provider: :red_candle, model: MODEL)
+  response = chat.with_schema(sentiment_schema).ask("Analyze: 'I absolutely love this product!'")
+
+  result "Response", response.content.inspect
+
+  if response.content.is_a?(Hash)
+    result "Sentiment", response.content["sentiment"]
+    result "Confidence", response.content["confidence"]
+    success "Enum-constrained output completed"
+  end
+
+  # ---------------------------------------------------------------------------
+  section "9. Structured Output with String Keys (Normalization)"
+  # ---------------------------------------------------------------------------
+
+  info "Testing schema with string keys (should be normalized to symbols)..."
+  string_key_schema = {
+    "type" => "object",
+    "properties" => {
+      "answer" => { "type" => "string" }
+    },
+    "required" => ["answer"]
+  }
+
+  chat = RubyLLM.chat(provider: :red_candle, model: MODEL)
+  response = chat.with_schema(string_key_schema).ask("What is 3 + 3?")
+
+  result "Response", response.content.inspect
+  success "String key normalization completed"
+
+  # ---------------------------------------------------------------------------
+  section "10. Schema Validation"
+  # ---------------------------------------------------------------------------
+
+  info "Testing schema validation with invalid schema..."
+  begin
+    invalid_schema = { type: "object" } # Missing 'properties'
+    chat = RubyLLM.chat(provider: :red_candle, model: MODEL)
+    chat.with_schema(invalid_schema).ask("This should fail")
+    puts "  [FAIL] Should have raised a validation error"
+  rescue RubyLLM::Error => e
+    result "Validation error caught", e.message.lines.first.strip
+    success "Schema validation works correctly"
+  end
+
+  info "Testing with non-object schema type..."
+  begin
+    array_schema = { type: "array", items: { type: "string" } }
+    chat = RubyLLM.chat(provider: :red_candle, model: MODEL)
+    chat.with_schema(array_schema).ask("This should fail")
+    puts "  [FAIL] Should have raised a validation error"
+  rescue RubyLLM::Error => e
+    result "Type error caught", e.message.lines.first.strip
+    success "Non-object schema rejection works correctly"
+  end
+
+  # ---------------------------------------------------------------------------
+  section "11. Custom JSON Instruction Template"
+  # ---------------------------------------------------------------------------
+
+  info "Current default template:"
+  result "Default", RubyLLM::RedCandle::Configuration.json_instruction_template[0..60] + "..."
+
+  info "Setting custom template..."
+  RubyLLM::RedCandle::Configuration.json_instruction_template = <<~TEMPLATE
+
+    OUTPUT FORMAT: You must respond with valid JSON containing: {schema_description}
+    No other text allowed, only the JSON object.
+  TEMPLATE
+
+  result "Custom template set", RubyLLM::RedCandle::Configuration.json_instruction_template.lines.first.strip
+
+  info "Testing structured output with custom template..."
+  chat = RubyLLM.chat(provider: :red_candle, model: MODEL)
+  custom_schema = {
+    type: "object",
+    properties: {
+      greeting: { type: "string" }
+    },
+    required: ["greeting"]
+  }
+  response = chat.with_schema(custom_schema).ask("Say hello")
+
+  result "Response", response.content.inspect
+  success "Custom template structured output completed"
+
+  info "Resetting to default template..."
+  RubyLLM::RedCandle::Configuration.reset!
+  result "Template reset", RubyLLM::RedCandle::Configuration.json_instruction_template[0..60] + "..."
+  success "Configuration reset works correctly"
+
+  # ---------------------------------------------------------------------------
+  section "12. Error Handling"
+  # ---------------------------------------------------------------------------
+
+  info "Testing error handling with invalid model..."
+  begin
+    RubyLLM.chat(provider: :red_candle, model: "invalid/nonexistent-model")
+    puts "  [FAIL] Should have raised an error"
+  rescue RubyLLM::Error => e
+    result "Error caught", e.message[0..60]
+    success "Error handling works correctly"
+  end
+
+  # ---------------------------------------------------------------------------
+  section "Summary"
+  # ---------------------------------------------------------------------------
+
+  puts "  All smoke tests completed successfully!"
+  puts
+  puts "  To run with a different model:"
+  puts "    SMOKE_TEST_MODEL='Qwen/Qwen2.5-1.5B-Instruct-GGUF' bundle exec ruby examples/smoke_test.rb"
+  puts
+  puts "  To skip slow tests:"
+  puts "    SKIP_SLOW=1 bundle exec ruby examples/smoke_test.rb"
+  puts
+
+rescue StandardError => e
+  puts
+  puts "  [ERROR] #{e.class}: #{e.message}"
+  puts e.backtrace.first(5).map { |line| "    #{line}" }.join("\n")
+  exit 1
+end

data/lib/ruby_llm/red_candle/capabilities.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module RedCandle
+    # Determines capabilities for RedCandle models
+    module Capabilities
+      module_function
+
+      def supports_vision?
+        false
+      end
+
+      def supports_functions?(_model_id = nil)
+        false
+      end
+
+      def supports_streaming?
+        true
+      end
+
+      def supports_structured_output?
+        true
+      end
+
+      def supports_regex_constraints?
+        true
+      end
+
+      def supports_embeddings?
+        false # Future enhancement - Red Candle does support embedding models
+      end
+
+      def supports_audio?
+        false
+      end
+
+      def supports_pdf?
+        false
+      end
+
+      def normalize_temperature(temperature, _model_id)
+        # Red Candle uses standard 0-2 range
+        return 0.7 if temperature.nil?
+
+        temperature = temperature.to_f
+        temperature.clamp(0.0, 2.0)
+      end
+
+      def model_context_window(model_id)
+        case model_id
+        when /gemma-3-4b/i
+          8192
+        when /qwen2\.5-1\.5b/i, /mistral-7b/i
+          32_768
+        when /tinyllama/i
+          2048
+        else
+          4096 # Conservative default
+        end
+      end
+
+      def default_max_tokens
+        512
+      end
+
+      def max_temperature
+        2.0
+      end
+
+      def min_temperature
+        0.0
+      end
+
+      def supports_temperature?
+        true
+      end
+
+      def supports_top_p?
+        true
+      end
+
+      def supports_top_k?
+        true
+      end
+
+      def supports_repetition_penalty?
+        true
+      end
+
+      def supports_seed?
+        true
+      end
+
+      def supports_stop_sequences?
+        true
+      end
+
+      def model_families
+        %w[gemma llama qwen2 mistral phi]
+      end
+
+      def available_on_platform?
+        # Check if Candle can be loaded
+
+        require "candle"
+        true
+      rescue LoadError
+        false
+      end
+    end
+  end
+end