OpenRouter Enhanced - Ruby Gem

gem "open_router_enhanced"

require "open_router"

# Configure the gem
OpenRouter.configure do |config|
  config.access_token = ENV["OPENROUTER_API_KEY"]
  config.site_name = "Your App Name"
  config.site_url = "https://yourapp.com"
end

# Create a client
client = OpenRouter::Client.new

# Basic completion
response = client.complete([
  { role: "user", content: "What is the capital of France?" }
])

puts response.content
# => "The capital of France is Paris."

# Smart model selection with capabilities
model = OpenRouter::ModelSelector.new
  .require(:function_calling)
  .optimize_for(:cost)
  .choose

# Define a tool
weather_tool = OpenRouter::Tool.define do
  name "get_weather"
  description "Get current weather"
  parameters do
    string :location, required: true
  end
end

# Define a schema for structured output
weather_schema = OpenRouter::Schema.define("weather") do
  string :location, required: true
  number :temperature, required: true
  string :conditions, required: true
end

# Use everything together
response = client.complete(
  [{ role: "user", content: "What's the weather in Tokyo?" }],
  model: model,
  tools: [weather_tool],
  response_format: weather_schema
)

# Process results
if response.has_tool_calls?
  weather_data = response.structured_output
  puts "Temperature in #{weather_data['location']}: #{weather_data['temperature']}°"
end

OpenRouter.configure do |config|
  # Required
  config.access_token = ENV["OPENROUTER_API_KEY"]
  config.site_name = "Your App Name"
  config.site_url = "https://yourapp.com"

  # Optional: Response healing for non-native structured output models
  config.auto_heal_responses = true
  config.healer_model = "openai/gpt-4o-mini"
  config.max_heal_attempts = 2

  # Optional: Strict mode for capability validation
  config.strict_mode = true

  # Optional: Request timeout (default: 120 seconds)
  config.request_timeout = 120
end

client = OpenRouter::Client.new(
  access_token: ENV["OPENROUTER_API_KEY"],
  request_timeout: 240
)

require 'faraday/retry'

OpenRouter::Client.new(access_token: ENV["ACCESS_TOKEN"]) do |config|
  config.faraday do |f|
    f.request :retry, max: 2, interval: 0.05
    f.response :logger, ::Logger.new($stdout), { headers: true, bodies: true }
  end
end

# Define a tool with the DSL
weather_tool = OpenRouter::Tool.define do
  name "get_weather"
  description "Get current weather for a location"

  parameters do
    string :location, required: true, description: "City name"
    string :units, enum: ["celsius", "fahrenheit"], default: "celsius"
  end
end

# Use in completion
response = client.complete(
  [{ role: "user", content: "What's the weather in London?" }],
  model: "anthropic/claude-3.5-sonnet",
  tools: [weather_tool]
)

# Handle tool calls
if response.has_tool_calls?
  response.tool_calls.each do |tool_call|
    result = fetch_weather(tool_call.arguments["location"])
    puts "Weather: #{result}"
  end
end

# Define a schema
user_schema = OpenRouter::Schema.define("user") do
  string :name, required: true, description: "Full name"
  integer :age, required: true, minimum: 0, maximum: 150
  string :email, required: true
  boolean :premium, description: "Premium account status"
end

# Get structured response
response = client.complete(
  [{ role: "user", content: "Create a user: John Doe, 30, john@example.com" }],
  model: "openai/gpt-4o",
  response_format: user_schema
)

# Access parsed JSON
user = response.structured_output
puts "#{user['name']} (#{user['age']}) - #{user['email']}"

# Find cheapest model with function calling
model = OpenRouter::ModelSelector.new
  .require(:function_calling)
  .optimize_for(:cost)
  .choose

# Advanced selection with multiple criteria
model = OpenRouter::ModelSelector.new
  .require(:function_calling, :vision)
  .within_budget(max_cost: 0.01)
  .min_context(50_000)
  .prefer_providers("anthropic", "openai")
  .optimize_for(:performance)
  .choose

# Get multiple options for fallbacks
models = OpenRouter::ModelSelector.new
  .require(:structured_outputs)
  .choose_with_fallbacks(limit: 3)
# => ["openai/gpt-4o-mini", "anthropic/claude-3-haiku", "google/gemini-flash"]

# Basic template
translation_template = OpenRouter::PromptTemplate.new(
  template: "Translate '{text}' from {source_lang} to {target_lang}",
  input_variables: [:text, :source_lang, :target_lang]
)

response = client.complete(
  translation_template.to_messages(
    text: "Hello world",
    source_lang: "English",
    target_lang: "French"
  ),
  model: "openai/gpt-4o-mini"
)

# Few-shot learning template
classification_template = OpenRouter::PromptTemplate.new(
  prefix: "Classify the sentiment:",
  suffix: "Now classify: {text}",
  examples: [
    { text: "I love this!", sentiment: "positive" },
    { text: "This is terrible.", sentiment: "negative" }
  ],
  example_template: "Text: {text}\nSentiment: {sentiment}",
  input_variables: [:text]
)

streaming_client = OpenRouter::StreamingClient.new

# Set up callbacks
streaming_client
  .on_stream(:on_start) { |data| puts "Starting..." }
  .on_stream(:on_chunk) { |chunk| print chunk.content }
  .on_stream(:on_finish) { |response| puts "\nDone! Tokens: #{response.total_tokens}" }
  .on_stream(:on_error) { |error| puts "Error: #{error.message}" }

# Stream with automatic response accumulation
response = streaming_client.stream_complete(
  [{ role: "user", content: "Write a story about a robot" }],
  model: "openai/gpt-4o-mini",
  accumulate_response: true
)

puts "Final response: #{response.content}"

# Enable tracking
client = OpenRouter::Client.new(track_usage: true)

# Make requests
3.times do
  response = client.complete(
    [{ role: "user", content: "Tell me a fact" }],
    model: "openai/gpt-4o-mini"
  )
end

# View statistics
tracker = client.usage_tracker
puts "Total requests: #{tracker.request_count}"
puts "Total tokens: #{tracker.total_tokens}"
puts "Total cost: $#{tracker.total_cost.round(4)}"

# Per-model breakdown
tracker.model_usage.each do |model, stats|
  puts "#{model}: #{stats[:total_tokens]} tokens, $#{stats[:cost].round(4)}"
end

# Print detailed report
tracker.print_summary

# Set your API key
export OPENROUTER_API_KEY="your_key_here"

# Or in code
OpenRouter.configure do |config|
  config.access_token = ENV["OPENROUTER_API_KEY"]
end

# Use ModelSelector to find compatible models
model = OpenRouter::ModelSelector.new
  .require(:function_calling)
  .choose

# Enable automatic healing
OpenRouter.configure do |config|
  config.auto_heal_responses = true
  config.healer_model = "openai/gpt-4o-mini"
end

# Optimize configuration
client = OpenRouter::Client.new(
  request_timeout: 30,
  strict_mode: false,
  auto_heal_responses: false
)

require 'logger'

OpenRouter.configure do |config|
  config.log_errors = true
  config.faraday do |f|
    f.response :logger, Logger.new($stdout), { headers: true, bodies: true, errors: true }
  end
end