Introducing Google Gemini Support

require 'dspy'

# Configure DSPy with Gemini
DSPy.configure do |c|
  c.lm = DSPy::LM.new('gemini/gemini-1.5-flash', api_key: ENV['GEMINI_API_KEY'])
end

class ContentAnalysis < DSPy::Signature
  description "Analyze written content for key insights and metrics"
  
  # Define enums for controlled outputs
  class Sentiment < T::Enum
    enums do
      Positive = new('positive')
      Negative = new('negative') 
      Neutral = new('neutral')
      Mixed = new('mixed')
    end
  end
  
  class ContentType < T::Enum
    enums do
      Article = new('article')
      BlogPost = new('blog_post')
      Review = new('review')
      SocialMedia = new('social_media')
      Academic = new('academic')
      Marketing = new('marketing')
    end
  end
  
  input do
    const :content, String
  end
  
  output do
    const :sentiment, Sentiment
    const :content_type, ContentType
    const :key_topics, T::Array[String]
    const :readability_score, Float  # 1-10 scale
    const :word_count, Integer
    const :main_idea, String
    const :target_audience, String
  end
end

# Create the analyzer
analyzer = DSPy::Predict.new(ContentAnalysis)

# Analyze some content
result = analyzer.forward(
  content: "Ruby has always been my favorite programming language. Its elegant " \
           "syntax and developer happiness philosophy make complex tasks feel " \
           "intuitive. The community support is incredible, and gems like DSPy.rb " \
           "show how Ruby continues to innovate in the AI space."
)

# Access results with full type safety
puts "Sentiment: #{result.sentiment}"           # => Sentiment::Positive
puts "Type: #{result.content_type}"            # => ContentType::BlogPost  
puts "Topics: #{result.key_topics.join(', ')}" # => Ruby, programming, community
puts "Readability: #{result.readability_score}/10"
puts "Main idea: #{result.main_idea}"

class ProductImageAnalysis < DSPy::Signature
  description "Analyze product images to extract detailed information for e-commerce"
  
  class Condition < T::Enum
    enums do
      New = new('new')
      LikeNew = new('like_new') 
      Good = new('good')
      Fair = new('fair')
      Poor = new('poor')
    end
  end
  
  class Category < T::Enum
    enums do
      Electronics = new('electronics')
      Clothing = new('clothing')
      HomeGarden = new('home_garden')
      Sports = new('sports')
      Automotive = new('automotive')
      Books = new('books')
    end
  end
  
  input do
    const :product_image, DSPy::Image
    const :seller_description, String
  end
  
  output do
    const :category, Category
    const :condition, Condition
    const :brand, T.nilable(String)
    const :key_features, T::Array[String]
    const :colors, T::Array[String] 
    const :estimated_age, T.nilable(String)
    const :authenticity_concerns, T::Array[String]
    const :recommended_price_range, String
  end
end

# Load an image (from file as base64)
product_image = DSPy::Image.new(
  base64: Base64.strict_encode64(File.read('product_photo.jpg', mode: 'rb')),
  content_type: 'image/jpeg'
)

# Create the analyzer
analyzer = DSPy::Predict.new(ProductImageAnalysis)

# Analyze the product
result = analyzer.forward(
  product_image: product_image,
  seller_description: "Vintage leather jacket, worn a few times, great condition"
)

# Access multimodal analysis results
puts "Category: #{result.category}"
puts "Condition: #{result.condition}"
puts "Brand: #{result.brand || 'Unknown'}"
puts "Features: #{result.key_features.join(', ')}"
puts "Colors: #{result.colors.join(', ')}"
puts "Price range: #{result.recommended_price_range}"

if result.authenticity_concerns.any?
  puts "Authenticity concerns: #{result.authenticity_concerns.join('; ')}"
end

class ImageComparison < DSPy::Signature
  description "Compare multiple images and provide detailed analysis"
  
  input do
    const :images, T::Array[DSPy::Image]
    const :comparison_criteria, String
  end
  
  output do
    const :similarities, T::Array[String]
    const :differences, T::Array[String]
    const :quality_ranking, T::Array[Integer]  # Ranked by quality 1st, 2nd, etc.
    const :recommendation, String
  end
end

# Load multiple product images
images = [
  DSPy::Image.new(base64: Base64.strict_encode64(File.read('laptop1.jpg', mode: 'rb')), content_type: 'image/jpeg'),
  DSPy::Image.new(base64: Base64.strict_encode64(File.read('laptop2.jpg', mode: 'rb')), content_type: 'image/jpeg'), 
  DSPy::Image.new(base64: Base64.strict_encode64(File.read('laptop3.jpg', mode: 'rb')), content_type: 'image/jpeg')
]

comparator = DSPy::Predict.new(ImageComparison)

result = comparator.forward(
  images: images,
  comparison_criteria: "Compare these laptops for build quality, screen clarity, and overall condition"
)

puts "Similarities: #{result.similarities.join(', ')}"
puts "Differences: #{result.differences.join(', ')}"
puts "Quality ranking: #{result.quality_ranking}"
puts "Recommendation: #{result.recommendation}"

class TechnicalDiagnostic < DSPy::Signature
  description "Diagnose technical issues with detailed reasoning"
  
  input do
    const :symptoms, String
    const :system_specs, String
    const :recent_changes, String
  end
  
  output do
    const :root_cause, String
    const :confidence_level, Float  # 0-1
    const :solution_steps, T::Array[String]
    const :prevention_tips, T::Array[String]
    const :escalation_needed, T::Boolean
  end
end

# Use Chain of Thought for transparent reasoning
diagnostic = DSPy::ChainOfThought.new(TechnicalDiagnostic)

result = diagnostic.forward(
  symptoms: "Application randomly crashes with memory errors after 2-3 hours",
  system_specs: "16GB RAM, Ruby 3.3, Rails 7.1, PostgreSQL 15",
  recent_changes: "Recently added image processing with ImageMagick"
)

# Access both the reasoning and the conclusion
puts "Reasoning process:"
puts result.reasoning
puts "\nRoot cause: #{result.root_cause}"
puts "Confidence: #{(result.confidence_level * 100).round}%"
puts "Solution steps:"
result.solution_steps.each_with_index do |step, i|
  puts "  #{i + 1}. #{step}"
end

# Standard configuration - no generation parameters at DSPy level
DSPy.configure do |c|
  c.lm = DSPy::LM.new('gemini/gemini-1.5-pro', api_key: ENV['GEMINI_API_KEY'])
end

predictor = DSPy::Predict.new(YourSignature)
result = predictor.forward(input: "Your input text")

# Safety errors are automatically handled by the adapter
begin
  result = predictor.forward(input: "Your content")
rescue DSPy::LM::AdapterError => e
  if e.message.include?('blocked by safety filters')
    puts "Content was filtered for safety reasons"
    # Handle appropriately - perhaps rephrase or provide alternative content
  else
    raise e
  end
end

# ✅ Works with Gemini
image = DSPy::Image.new(
  base64: base64_data,
  content_type: 'image/jpeg'  # png, gif, webp also supported
)

# ❌ Not supported by Gemini  
image = DSPy::Image.new(url: 'https://example.com/image.jpg')

# Access detailed usage information
adapter = lm.instance_variable_get(:@adapter)
response = adapter.chat(messages: [...])

puts "Input tokens: #{response.usage.input_tokens}"
puts "Output tokens: #{response.usage.output_tokens}" 
puts "Total tokens: #{response.usage.total_tokens}"

# Use for cost estimation
input_cost = response.usage.input_tokens * GEMINI_INPUT_RATE
output_cost = response.usage.output_tokens * GEMINI_OUTPUT_RATE
total_cost = input_cost + output_cost

# Example: Environment-based model selection
DSPy.configure do |c|
  model = case Rails.env
          when 'development' then 'gemini/gemini-1.5-flash'    # Fast iteration
          when 'test' then 'gemini/gemini-1.5-flash'          # Consistent tests
          when 'production' then 'gemini/gemini-1.5-pro'      # Best quality
          end
          
  c.lm = DSPy::LM.new(model, api_key: ENV['GEMINI_API_KEY'])
end

begin
  result = predictor.forward(input: "Your input")
rescue DSPy::LM::AdapterError => e
  case e.message
  when /authentication failed/
    puts "Check your GEMINI_API_KEY"
  when /rate limit/
    puts "Rate limited, retry with backoff"
  when /safety filters/
    puts "Content blocked by safety filters"
  when /image processing failed/
    puts "Image format or size issue"
  else
    puts "Unexpected error: #{e.message}"
  end
end

# Before: OpenAI
DSPy.configure do |c|
  c.lm = DSPy::LM.new('openai/gpt-4o-mini', api_key: ENV['OPENAI_API_KEY'])
end

# After: Gemini
DSPy.configure do |c|
  c.lm = DSPy::LM.new('gemini/gemini-1.5-flash', api_key: ENV['GEMINI_API_KEY'])
end

# Your signatures and predictors work exactly the same!