ruby_llm 1.2.0 → 1.3.0

data/lib/ruby_llm/aliases.json

@@ -1,38 +1,208 @@
 {
-  "claude-3-5-sonnet": {
-    "anthropic": "claude-3-5-sonnet-20241022",
-    "bedrock": "anthropic.claude-3-5-sonnet-20241022-v2:0"
+  "chatgpt-4o": {
+    "openai": "chatgpt-4o-latest",
+    "openrouter": "openai/chatgpt-4o-latest"
+  },
+  "claude-2.0": {
+    "anthropic": "claude-2.0",
+    "openrouter": "anthropic/claude-2.0",
+    "bedrock": "anthropic.claude-v2:1:200k"
+  },
+  "claude-2.1": {
+    "anthropic": "claude-2.1",
+    "openrouter": "anthropic/claude-2.1",
+    "bedrock": "anthropic.claude-v2:1:200k"
   },
   "claude-3-5-haiku": {
     "anthropic": "claude-3-5-haiku-20241022",
+    "openrouter": "anthropic/claude-3.5-haiku",
     "bedrock": "anthropic.claude-3-5-haiku-20241022-v1:0"
   },
+  "claude-3-5-sonnet": {
+    "anthropic": "claude-3-5-sonnet-20241022",
+    "openrouter": "anthropic/claude-3.5-sonnet",
+    "bedrock": "anthropic.claude-3-5-sonnet-20240620-v1:0:200k"
+  },
   "claude-3-7-sonnet": {
     "anthropic": "claude-3-7-sonnet-20250219",
+    "openrouter": "anthropic/claude-3.7-sonnet",
     "bedrock": "us.anthropic.claude-3-7-sonnet-20250219-v1:0"
   },
+  "claude-3-haiku": {
+    "anthropic": "claude-3-haiku-20240307",
+    "openrouter": "anthropic/claude-3-haiku",
+    "bedrock": "anthropic.claude-3-haiku-20240307-v1:0:200k"
+  },
   "claude-3-opus": {
     "anthropic": "claude-3-opus-20240229",
-    "bedrock": "anthropic.claude-3-opus-20240229-v1:0"
+    "openrouter": "anthropic/claude-3-opus",
+    "bedrock": "anthropic.claude-3-opus-20240229-v1:0:200k"
   },
   "claude-3-sonnet": {
     "anthropic": "claude-3-sonnet-20240229",
-    "bedrock": "anthropic.claude-3-sonnet-20240229-v1:0"
+    "openrouter": "anthropic/claude-3-sonnet",
+    "bedrock": "anthropic.claude-3-sonnet-20240229-v1:0:200k"
   },
-  "claude-3-haiku": {
-    "anthropic": "claude-3-haiku-20240307",
-    "bedrock": "anthropic.claude-3-haiku-20240307-v1:0"
+  "claude-opus-4": {
+    "anthropic": "claude-opus-4-20250514",
+    "openrouter": "anthropic/claude-opus-4",
+    "bedrock": "us.anthropic.claude-opus-4-20250514-v1:0"
   },
-  "claude-3": {
-    "anthropic": "claude-3-sonnet-20240229",
-    "bedrock": "anthropic.claude-3-sonnet-20240229-v1:0"
+  "claude-sonnet-4": {
+    "anthropic": "claude-sonnet-4-20250514",
+    "openrouter": "anthropic/claude-sonnet-4",
+    "bedrock": "us.anthropic.claude-sonnet-4-20250514-v1:0"
   },
-  "claude-2": {
-    "anthropic": "claude-2.0",
-    "bedrock": "anthropic.claude-2.0"
+  "deepseek-chat": {
+    "deepseek": "deepseek-chat",
+    "openrouter": "deepseek/deepseek-chat"
   },
-  "claude-2-1": {
-    "anthropic": "claude-2.1",
-    "bedrock": "anthropic.claude-2.1"
+  "gemini-2.0-flash-001": {
+    "gemini": "gemini-2.0-flash-001",
+    "openrouter": "google/gemini-2.0-flash-001"
+  },
+  "gemini-2.0-flash-lite-001": {
+    "gemini": "gemini-2.0-flash-lite-001",
+    "openrouter": "google/gemini-2.0-flash-lite-001"
+  },
+  "gemini-2.5-flash-preview-05-20": {
+    "gemini": "gemini-2.5-flash-preview-05-20",
+    "openrouter": "google/gemini-2.5-flash-preview-05-20"
+  },
+  "gemini-2.5-pro-exp-03-25": {
+    "gemini": "gemini-2.5-pro-exp-03-25",
+    "openrouter": "google/gemini-2.5-pro-exp-03-25"
+  },
+  "gemma-3-12b-it": {
+    "gemini": "gemma-3-12b-it",
+    "openrouter": "google/gemma-3-12b-it"
+  },
+  "gemma-3-27b-it": {
+    "gemini": "gemma-3-27b-it",
+    "openrouter": "google/gemma-3-27b-it"
+  },
+  "gemma-3-4b-it": {
+    "gemini": "gemma-3-4b-it",
+    "openrouter": "google/gemma-3-4b-it"
+  },
+  "gpt-3.5-turbo": {
+    "openai": "gpt-3.5-turbo",
+    "openrouter": "openai/gpt-3.5-turbo"
+  },
+  "gpt-3.5-turbo-0125": {
+    "openai": "gpt-3.5-turbo-0125",
+    "openrouter": "openai/gpt-3.5-turbo-0125"
+  },
+  "gpt-3.5-turbo-1106": {
+    "openai": "gpt-3.5-turbo-1106",
+    "openrouter": "openai/gpt-3.5-turbo-1106"
+  },
+  "gpt-3.5-turbo-16k": {
+    "openai": "gpt-3.5-turbo-16k",
+    "openrouter": "openai/gpt-3.5-turbo-16k"
+  },
+  "gpt-3.5-turbo-instruct": {
+    "openai": "gpt-3.5-turbo-instruct",
+    "openrouter": "openai/gpt-3.5-turbo-instruct"
+  },
+  "gpt-4": {
+    "openai": "gpt-4",
+    "openrouter": "openai/gpt-4"
+  },
+  "gpt-4-1106-preview": {
+    "openai": "gpt-4-1106-preview",
+    "openrouter": "openai/gpt-4-1106-preview"
+  },
+  "gpt-4-turbo": {
+    "openai": "gpt-4-turbo",
+    "openrouter": "openai/gpt-4-turbo"
+  },
+  "gpt-4-turbo-preview": {
+    "openai": "gpt-4-turbo-preview",
+    "openrouter": "openai/gpt-4-turbo-preview"
+  },
+  "gpt-4.1": {
+    "openai": "gpt-4.1",
+    "openrouter": "openai/gpt-4.1"
+  },
+  "gpt-4.1-mini": {
+    "openai": "gpt-4.1-mini",
+    "openrouter": "openai/gpt-4.1-mini"
+  },
+  "gpt-4.1-nano": {
+    "openai": "gpt-4.1-nano",
+    "openrouter": "openai/gpt-4.1-nano"
+  },
+  "gpt-4.5-preview": {
+    "openai": "gpt-4.5-preview",
+    "openrouter": "openai/gpt-4.5-preview"
+  },
+  "gpt-4o": {
+    "openai": "gpt-4o",
+    "openrouter": "openai/gpt-4o"
+  },
+  "gpt-4o-2024-05-13": {
+    "openai": "gpt-4o-2024-05-13",
+    "openrouter": "openai/gpt-4o-2024-05-13"
+  },
+  "gpt-4o-2024-08-06": {
+    "openai": "gpt-4o-2024-08-06",
+    "openrouter": "openai/gpt-4o-2024-08-06"
+  },
+  "gpt-4o-2024-11-20": {
+    "openai": "gpt-4o-2024-11-20",
+    "openrouter": "openai/gpt-4o-2024-11-20"
+  },
+  "gpt-4o-mini": {
+    "openai": "gpt-4o-mini",
+    "openrouter": "openai/gpt-4o-mini"
+  },
+  "gpt-4o-mini-2024-07-18": {
+    "openai": "gpt-4o-mini-2024-07-18",
+    "openrouter": "openai/gpt-4o-mini-2024-07-18"
+  },
+  "gpt-4o-mini-search-preview": {
+    "openai": "gpt-4o-mini-search-preview",
+    "openrouter": "openai/gpt-4o-mini-search-preview"
+  },
+  "gpt-4o-search-preview": {
+    "openai": "gpt-4o-search-preview",
+    "openrouter": "openai/gpt-4o-search-preview"
+  },
+  "o1": {
+    "openai": "o1",
+    "openrouter": "openai/o1"
+  },
+  "o1-mini": {
+    "openai": "o1-mini",
+    "openrouter": "openai/o1-mini"
+  },
+  "o1-mini-2024-09-12": {
+    "openai": "o1-mini-2024-09-12",
+    "openrouter": "openai/o1-mini-2024-09-12"
+  },
+  "o1-preview": {
+    "openai": "o1-preview",
+    "openrouter": "openai/o1-preview"
+  },
+  "o1-preview-2024-09-12": {
+    "openai": "o1-preview-2024-09-12",
+    "openrouter": "openai/o1-preview-2024-09-12"
+  },
+  "o1-pro": {
+    "openai": "o1-pro",
+    "openrouter": "openai/o1-pro"
+  },
+  "o3": {
+    "openai": "o3",
+    "openrouter": "openai/o3"
+  },
+  "o3-mini": {
+    "openai": "o3-mini",
+    "openrouter": "openai/o3-mini"
+  },
+  "o4-mini": {
+    "openai": "o4-mini",
+    "openrouter": "openai/o4-mini"
   }
 }

data/lib/ruby_llm/attachment.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  # A class representing a file attachment.
+  class Attachment
+    attr_reader :source, :filename, :mime_type
+
+    def initialize(source, filename: nil)
+      @source = source
+      if url?
+        @source = URI source
+        @filename = filename || File.basename(@source.path).to_s
+      elsif path?
+        @source = Pathname.new source
+        @filename = filename || @source.basename.to_s
+      elsif active_storage?
+        @filename = filename || extract_filename_from_active_storage
+      else
+        @filename = filename
+      end
+
+      determine_mime_type
+    end
+
+    def url?
+      @source.is_a?(URI) || (@source.is_a?(String) && @source.match?(%r{^https?://}))
+    end
+
+    def path?
+      @source.is_a?(Pathname) || (@source.is_a?(String) && !url?)
+    end
+
+    def io_like?
+      @source.respond_to?(:read) && !path? && !active_storage?
+    end
+
+    def active_storage?
+      return false unless defined?(ActiveStorage)
+
+      @source.is_a?(ActiveStorage::Blob) ||
+        @source.is_a?(ActiveStorage::Attached::One) ||
+        @source.is_a?(ActiveStorage::Attached::Many)
+    end
+
+    def content
+      return @content if defined?(@content) && !@content.nil?
+
+      if url?
+        fetch_content
+      elsif path?
+        load_content_from_path
+      elsif active_storage?
+        load_content_from_active_storage
+      elsif io_like?
+        load_content_from_io
+      else
+        RubyLLM.logger.warn "Source is neither a URL, path, ActiveStorage, nor IO-like: #{@source.class}"
+        nil
+      end
+
+      @content
+    end
+
+    def encoded
+      Base64.strict_encode64(content)
+    end
+
+    def type
+      return :image if image?
+      return :audio if audio?
+      return :pdf if pdf?
+      return :text if text?
+
+      :unknown
+    end
+
+    def image?
+      RubyLLM::MimeType.image? mime_type
+    end
+
+    def audio?
+      RubyLLM::MimeType.audio? mime_type
+    end
+
+    def pdf?
+      RubyLLM::MimeType.pdf? mime_type
+    end
+
+    def text?
+      RubyLLM::MimeType.text? mime_type
+    end
+
+    def to_h
+      { type: type, source: @source }
+    end
+
+    private
+
+    def determine_mime_type
+      return @mime_type = active_storage_content_type if active_storage? && active_storage_content_type.present?
+
+      @mime_type = RubyLLM::MimeType.for(@source, name: @filename)
+      @mime_type = RubyLLM::MimeType.for(content) if @mime_type == 'application/octet-stream'
+      @mime_type = 'audio/wav' if @mime_type == 'audio/x-wav' # Normalize WAV type
+    end
+
+    def fetch_content
+      response = Connection.basic.get @source.to_s
+      @content = response.body
+    end
+
+    def load_content_from_path
+      @content = File.read(@source)
+    end
+
+    def load_content_from_io
+      @source.rewind if @source.respond_to? :rewind
+      @content = @source.read
+    end
+
+    def load_content_from_active_storage
+      return unless defined?(ActiveStorage)
+
+      @content = case @source
+                 when ActiveStorage::Blob
+                   @source.download
+                 when ActiveStorage::Attached::One
+                   @source.blob&.download
+                 when ActiveStorage::Attached::Many
+                   # For multiple attachments, just take the first one
+                   # This maintains the single-attachment interface
+                   @source.blobs.first&.download
+                 end
+    end
+
+    def extract_filename_from_active_storage # rubocop:disable Metrics/PerceivedComplexity
+      return 'attachment' unless defined?(ActiveStorage)
+
+      case @source
+      when ActiveStorage::Blob
+        @source.filename.to_s
+      when ActiveStorage::Attached::One
+        @source.blob&.filename&.to_s || 'attachment'
+      when ActiveStorage::Attached::Many
+        @source.blobs.first&.filename&.to_s || 'attachment'
+      else
+        'attachment'
+      end
+    end
+
+    def active_storage_content_type
+      return unless defined?(ActiveStorage)
+
+      case @source
+      when ActiveStorage::Blob
+        @source.content_type
+      when ActiveStorage::Attached::One
+        @source.blob&.content_type
+      when ActiveStorage::Attached::Many
+        @source.blobs.first&.content_type
+      end
+    end
+  end
+end

data/lib/ruby_llm/chat.rb

@@ -8,17 +8,19 @@ module RubyLLM
   #   chat = RubyLLM.chat
   #   chat.ask "What's the best way to learn Ruby?"
   #   chat.ask "Can you elaborate on that?"
-  class Chat # rubocop:disable Metrics/ClassLength
+  class Chat
     include Enumerable
 
     attr_reader :model, :messages, :tools
 
-    def initialize(model: nil, provider: nil, assume_model_exists: false) # rubocop:disable Metrics/MethodLength
+    def initialize(model: nil, provider: nil, assume_model_exists: false, context: nil)
       if assume_model_exists && !provider
         raise ArgumentError, 'Provider must be specified if assume_model_exists is true'
       end
 
-      model_id = model || RubyLLM.config.default_model
+      @context = context
+      @config = context&.config || RubyLLM.config
+      model_id = model || @config.default_model
       with_model(model_id, provider: provider, assume_exists: assume_model_exists)
       @temperature = 0.7
       @messages = []
@@ -29,22 +31,22 @@ module RubyLLM
       }
     end
 
-    def ask(message = nil, with: {}, &block)
+    def ask(message = nil, with: nil, &)
       add_message role: :user, content: Content.new(message, with)
-      complete(&block)
+      complete(&)
     end
 
     alias say ask
 
     def with_instructions(instructions, replace: false)
-      @messages = @messages.reject! { |msg| msg.role == :system } if replace
+      @messages = @messages.reject { |msg| msg.role == :system } if replace
 
       add_message role: :system, content: instructions
       self
     end
 
     def with_tool(tool)
-      unless @model.supports_functions
+      unless @model.supports_functions?
         raise UnsupportedFunctionsError, "Model #{@model.id} doesn't support function calling"
       end
 
@@ -58,18 +60,9 @@ module RubyLLM
       self
     end
 
-    def with_model(model_id, provider: nil, assume_exists: false) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-      if assume_exists
-        raise ArgumentError, 'Provider must be specified if assume_exists is true' unless provider
-
-        @provider = Provider.providers[provider.to_sym] || raise(Error, "Unknown provider: #{provider.to_sym}")
-        @model = Struct.new(:id, :provider, :supports_functions, :supports_vision).new(model_id, provider, true, true)
-        RubyLLM.logger.warn "Assuming model '#{model_id}' exists for provider '#{provider}'. " \
-                            'Capabilities may not be accurately reflected.'
-      else
-        @model = Models.find model_id, provider
-        @provider = Provider.providers[@model.provider.to_sym] || raise(Error, "Unknown provider: #{@model.provider}")
-      end
+    def with_model(model_id, provider: nil, assume_exists: false)
+      @model, @provider = Models.resolve(model_id, provider:, assume_exists:)
+      @connection = @context ? @context.connection_for(@provider) : @provider.connection(@config)
       self
     end
 
@@ -78,6 +71,13 @@ module RubyLLM
       self
     end
 
+    def with_context(context)
+      @context = context
+      @config = context.config
+      with_model(@model.id, provider: @provider.slug, assume_exists: true)
+      self
+    end
+
     def on_new_message(&block)
       @on[:new_message] = block
       self
@@ -94,7 +94,14 @@ module RubyLLM
 
     def complete(&)
       @on[:new_message]&.call
-      response = @provider.complete(messages, tools: @tools, temperature: @temperature, model: @model.id, &)
+      response = @provider.complete(
+        messages,
+        tools: @tools,
+        temperature: @temperature,
+        model: @model.id,
+        connection: @connection,
+        &
+      )
       @on[:end_message]&.call(response)
 
       add_message response
@@ -111,6 +118,10 @@ module RubyLLM
       message
     end
 
+    def reset_messages!
+      @messages.clear
+    end
+
     private
 
     def handle_tool_calls(response, &)

data/lib/ruby_llm/configuration.rb

@@ -13,6 +13,8 @@ module RubyLLM
     # Provider-specific configuration
     attr_accessor :openai_api_key,
                   :openai_api_base,
+                  :openai_organization_id,
+                  :openai_project_id,
                   :anthropic_api_key,
                   :gemini_api_key,
                   :deepseek_api_key,
@@ -20,6 +22,8 @@ module RubyLLM
                   :bedrock_secret_key,
                   :bedrock_region,
                   :bedrock_session_token,
+                  :openrouter_api_key,
+                  :ollama_api_base,
                   # Default models
                   :default_model,
                   :default_embedding_model,
@@ -29,7 +33,12 @@ module RubyLLM
                   :max_retries,
                   :retry_interval,
                   :retry_backoff_factor,
-                  :retry_interval_randomness
+                  :retry_interval_randomness,
+                  :http_proxy,
+                  # Logging configuration
+                  :log_file,
+                  :log_level,
+                  :log_assume_model_exists
 
     def initialize
       # Connection configuration
@@ -38,11 +47,35 @@ module RubyLLM
       @retry_interval = 0.1
       @retry_backoff_factor = 2
       @retry_interval_randomness = 0.5
+      @http_proxy = nil
 
       # Default models
       @default_model = 'gpt-4.1-nano'
       @default_embedding_model = 'text-embedding-3-small'
       @default_image_model = 'dall-e-3'
+
+      # Logging configuration
+      @log_file = $stdout
+      @log_level = ENV['RUBYLLM_DEBUG'] ? Logger::DEBUG : Logger::INFO
+      @log_assume_model_exists = true
+    end
+
+    def inspect
+      redacted = lambda do |name, value|
+        if name.match?(/_id|_key|_secret|_token$/)
+          value.nil? ? 'nil' : '[FILTERED]'
+        else
+          value
+        end
+      end
+
+      inspection = instance_variables.map do |ivar|
+        name = ivar.to_s.delete_prefix('@')
+        value = redacted[name, instance_variable_get(ivar)]
+        "#{name}: #{value}"
+      end.join(', ')
+
+      "#<#{self.class}:0x#{object_id.to_s(16)} #{inspection}>"
     end
   end
 end

data/lib/ruby_llm/connection.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  # Connection class for managing API connections to various providers.
+  class Connection
+    attr_reader :provider, :connection, :config
+
+    def self.basic(&)
+      Faraday.new do |f|
+        f.response :logger,
+                   RubyLLM.logger,
+                   bodies: false,
+                   response: false,
+                   errors: true,
+                   headers: false,
+                   log_level: :debug
+        f.response :raise_error
+        yield f if block_given?
+      end
+    end
+
+    def initialize(provider, config)
+      @provider = provider
+      @config = config
+
+      ensure_configured!
+      @connection ||= Faraday.new(provider.api_base(@config)) do |faraday|
+        setup_timeout(faraday)
+        setup_logging(faraday)
+        setup_retry(faraday)
+        setup_middleware(faraday)
+        setup_http_proxy(faraday)
+      end
+    end
+
+    def post(url, payload, &)
+      body = payload.is_a?(Hash) ? JSON.generate(payload, ascii_only: false) : payload
+      @connection.post url, body do |req|
+        req.headers.merge! @provider.headers(@config) if @provider.respond_to?(:headers)
+        yield req if block_given?
+      end
+    end
+
+    def get(url, &)
+      @connection.get url do |req|
+        req.headers.merge! @provider.headers(@config) if @provider.respond_to?(:headers)
+        yield req if block_given?
+      end
+    end
+
+    private
+
+    def setup_timeout(faraday)
+      faraday.options.timeout = @config.request_timeout
+    end
+
+    def setup_logging(faraday)
+      faraday.response :logger,
+                       RubyLLM.logger,
+                       bodies: true,
+                       response: true,
+                       errors: true,
+                       headers: false,
+                       log_level: :debug do |logger|
+        logger.filter(%r{[A-Za-z0-9+/=]{100,}}, 'data":"[BASE64 DATA]"')
+        logger.filter(/[-\d.e,\s]{100,}/, '[EMBEDDINGS ARRAY]')
+      end
+    end
+
+    def setup_retry(faraday)
+      faraday.request :retry, {
+        max: @config.max_retries,
+        interval: @config.retry_interval,
+        interval_randomness: @config.retry_interval_randomness,
+        backoff_factor: @config.retry_backoff_factor,
+        exceptions: retry_exceptions,
+        retry_statuses: [429, 500, 502, 503, 504, 529]
+      }
+    end
+
+    def setup_middleware(faraday)
+      faraday.request :json
+      faraday.response :json
+      faraday.adapter Faraday.default_adapter
+      faraday.use :llm_errors, provider: @provider
+    end
+
+    def setup_http_proxy(faraday)
+      return unless @config.http_proxy
+
+      faraday.proxy = @config.http_proxy
+    end
+
+    def retry_exceptions
+      [
+        Errno::ETIMEDOUT,
+        Timeout::Error,
+        Faraday::TimeoutError,
+        Faraday::ConnectionFailed,
+        Faraday::RetriableResponse,
+        RubyLLM::RateLimitError,
+        RubyLLM::ServerError,
+        RubyLLM::ServiceUnavailableError,
+        RubyLLM::OverloadedError
+      ]
+    end
+
+    def ensure_configured!
+      return if @provider.configured?(@config)
+
+      config_block = <<~RUBY
+        RubyLLM.configure do |config|
+          #{@provider.missing_configs(@config).map { |key| "config.#{key} = ENV['#{key.to_s.upcase}']" }.join("\n  ")}
+        end
+      RUBY
+
+      raise ConfigurationError,
+            "#{@provider.slug} provider is not configured. Add this to your initialization:\n\n#{config_block}"
+    end
+  end
+end