gem 'llm_conductor'

require 'llm_conductor'

# Set up your API key (or use ENV variables)
LlmConductor.configure do |config|
  config.openai(api_key: 'your-api-key')
end

# Generate text
response = LlmConductor.generate(
  model: 'gpt-4o-mini',
  prompt: 'Explain quantum computing in simple terms'
)

puts response.output           # Generated text
puts response.total_tokens     # Token count
puts response.estimated_cost   # Cost in USD

# Control creativity with temperature
response = LlmConductor.generate(
  model: 'llama2',
  prompt: 'Write a creative story',
  vendor: :ollama,
  params: { temperature: 0.9 }
)

# Send images with your prompt
response = LlmConductor.generate(
  model: 'gpt-4o',
  prompt: {
    text: 'What is in this image?',
    images: ['https://example.com/image.jpg']
  }
)

LlmConductor.configure do |config|
  config.default_model = 'gpt-4o-mini'
  
  config.openai(api_key: ENV['OPENAI_API_KEY'])
  config.anthropic(api_key: ENV['ANTHROPIC_API_KEY'])
  config.gemini(api_key: ENV['GEMINI_API_KEY'])
  config.groq(api_key: ENV['GROQ_API_KEY'])
  config.ollama(base_url: 'http://localhost:11434')
  config.openrouter(api_key: ENV['OPENROUTER_API_KEY'])
  config.zai(api_key: ENV['ZAI_API_KEY'])
end

response = LlmConductor.generate(
  model: 'gpt-4o-mini',
  prompt: 'What is Ruby programming language?'
)

response = LlmConductor.generate(
  model: 'claude-3-5-sonnet-20241022',
  type: :summarize_text,
  data: {
    text: 'Long article content here...',
    max_length: '100 words',
    style: 'professional'
  }
)

response = LlmConductor.generate(
  model: 'llama2',
  prompt: 'Extract email addresses from: contact@example.com',
  vendor: :ollama,
  params: { temperature: 0.0, seed: 42 }
)

response = LlmConductor.generate(
  model: 'gpt-4o',
  prompt: {
    text: 'Describe this image in detail',
    images: [
      'https://example.com/photo.jpg',
      'https://example.com/diagram.png'
    ]
  }
)

response = LlmConductor.generate(...)

response.output           # String - Generated text
response.success?         # Boolean - Success status
response.model            # String - Model used
response.input_tokens     # Integer - Input token count
response.output_tokens    # Integer - Output token count
response.total_tokens     # Integer - Total tokens
response.estimated_cost   # Float - Cost in USD (if available)
response.metadata         # Hash - Additional info

# Parse JSON responses
response.parse_json       # Hash - Parsed JSON output

# Extract code blocks
response.extract_code_block('ruby')  # String - Code content

class AnalysisPrompt < LlmConductor::Prompts::BasePrompt
  def render
    <<~PROMPT
      Analyze: #{title}
      Content: #{truncate_text(content, max_length: 500)}
      
      Provide insights in JSON format.
    PROMPT
  end
end

# Register and use
LlmConductor::PromptManager.register(:analyze, AnalysisPrompt)

response = LlmConductor.generate(
  model: 'gpt-4o-mini',
  type: :analyze,
  data: { title: 'Article', content: '...' }
)

class CompanyDataBuilder < LlmConductor::DataBuilder
  def build
    {
      name: source_object.name,
      description: format_for_llm(source_object.description, max_length: 500),
      metrics: build_metrics,
      summary: build_company_summary
    }
  end
  
  private
  
  def build_metrics
    {
      employees: format_number(source_object.employee_count),
      revenue: format_number(source_object.annual_revenue, format: :currency)
    }
  end
end

response = LlmConductor.generate(...)

if response.success?
  puts response.output
else
  puts "Error: #{response.metadata[:error]}"
  puts "Error class: #{response.metadata[:error_class]}"
end

require 'llm_conductor/eval'

# 1. Describe how to evaluate your feature (the only feature-specific code).
class ArticleSummarySpec < LlmConductor::Eval::Spec
  def prompt_type        = :summarize_text                 # a registered prompt type
  def input_id(article)  = article[:id]
  def input_label(article) = article[:title]
  def build_data(article) = { content: article[:body] }    # payload for generate(type:, data:)

  # { score:, bucket: } — bucket is any discrete label; powers disagreement detection.
  def output_summary(parsed) = { score: parsed['rating'], bucket: parsed['verdict'] }

  def judge_rubric_excerpt = 'A good summary is faithful, concise, and covers the key points.'
  def judge_dimensions
    [{ key: 'faithfulness', description: 'no hallucinations vs. the source' },
     { key: 'coverage',     description: 'captures the key points' }]
  end
end

# 2. Run it. `inputs` is ANY enumerable — selection is YOUR job, never the gem's.
report = LlmConductor::Eval.run(
  spec:   ArticleSummarySpec.new,
  inputs: my_articles,
  models: [                                       # caller-owned; no baked-in defaults
    { model: 'phi4-mini',        vendor: :ollama },
    { model: 'gemini-2.5-flash', vendor: :gemini },
    { model: 'gpt-4o-mini',      vendor: :openai }
  ],
  judge:  { model: 'llama-3.3-70b-versatile', vendor: :groq },  # default; needs Groq creds
  store:  LlmConductor::Eval::Store::FileStore.new('tmp/llm_eval') # or in-memory (default)
)

report.summary       # per-model aggregates: parse-OK%, mean quality, p50/p95 latency, cost
report.to_markdown   # decision-aid report (you persist it)
report.to_csv        # full per-row data
report.needs_review  # rows flagged for a human (bucket disagreement / borderline / errors)

LlmConductor::Eval.judge_only(run_id:, spec:, store:, judge: { model: 'gemini-2.5-pro', vendor: :gemini })
LlmConductor::Eval.report_only(run_id:, spec:, store:)