ruby_llm 1.2.0 → 1.3.0rc1

data/lib/ruby_llm/aliases.json

@@ -1,15 +1,18 @@
 {
   "claude-3-5-sonnet": {
     "anthropic": "claude-3-5-sonnet-20241022",
-    "bedrock": "anthropic.claude-3-5-sonnet-20241022-v2:0"
+    "bedrock": "anthropic.claude-3-5-sonnet-20241022-v2:0",
+    "openrouter": "anthropic/claude-3.5-sonnet"
   },
   "claude-3-5-haiku": {
     "anthropic": "claude-3-5-haiku-20241022",
-    "bedrock": "anthropic.claude-3-5-haiku-20241022-v1:0"
+    "bedrock": "anthropic.claude-3-5-haiku-20241022-v1:0",
+    "openrouter": "anthropic/claude-3.5-haiku-20241022"
   },
   "claude-3-7-sonnet": {
     "anthropic": "claude-3-7-sonnet-20250219",
-    "bedrock": "us.anthropic.claude-3-7-sonnet-20250219-v1:0"
+    "bedrock": "us.anthropic.claude-3-7-sonnet-20250219-v1:0",
+    "openrouter": "us.anthropic.claude-3-7-sonnet-20250219-v1:0"
   },
   "claude-3-opus": {
     "anthropic": "claude-3-opus-20240229",
@@ -25,14 +28,53 @@
   },
   "claude-3": {
     "anthropic": "claude-3-sonnet-20240229",
-    "bedrock": "anthropic.claude-3-sonnet-20240229-v1:0"
+    "bedrock": "anthropic.claude-3-sonnet-20240229-v1:0",
+    "openrouter": "anthropic/claude-3-sonnet"
   },
   "claude-2": {
     "anthropic": "claude-2.0",
-    "bedrock": "anthropic.claude-2.0"
+    "bedrock": "anthropic.claude-2.0",
+    "openrouter": "anthropic/claude-2"
   },
   "claude-2-1": {
     "anthropic": "claude-2.1",
-    "bedrock": "anthropic.claude-2.1"
+    "bedrock": "anthropic.claude-2.1",
+    "openrouter": "anthropic/claude-2.1"
+  },
+  "gpt-4o": {
+    "openai": "gpt-4o",
+    "openrouter": "openai/gpt-4o"
+  },
+  "gpt-4o-mini": {
+    "openai": "gpt-4o-mini",
+    "openrouter": "openai/gpt-4o-mini"
+  },
+  "gpt-4-turbo": {
+    "openai": "gpt-4-turbo",
+    "openrouter": "openai/gpt-4-turbo"
+  },
+  "gemini-1.5-flash": {
+    "gemini": "gemini-1.5-flash",
+    "openrouter": "google/gemini-flash-1.5"
+  },
+  "gemini-1.5-flash-8b": {
+    "gemini": "gemini-1.5-flash-8b",
+    "openrouter": "google/gemini-flash-1.5-8b"
+  },
+  "gemini-1.5-pro": {
+    "gemini": "gemini-1.5-pro",
+    "openrouter": "google/gemini-pro-1.5"
+  },
+  "gemini-2.0-flash": {
+    "gemini": "gemini-2.0-flash",
+    "openrouter": "google/gemini-2.0-flash-001"
+  },
+  "o1": {
+    "openai": "o1",
+    "openrouter": "openai/o1"
+  },
+  "o3-mini": {
+    "openai": "o3-mini",
+    "openrouter": "openai/o3-mini"
   }
 }

data/lib/ruby_llm/attachments/audio.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Attachments
+    # Represents an audio attachment
+    class Audio < Base
+      def format
+        File.extname(@source).downcase.delete('.') || 'wav'
+      end
+    end
+  end
+end

data/lib/ruby_llm/attachments/image.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Attachments
+    # Represents an audio attachment
+    class Image < Base
+    end
+  end
+end

data/lib/ruby_llm/attachments/pdf.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Attachments
+    # Represents a PDF attachment
+    class PDF < Base
+    end
+  end
+end

data/lib/ruby_llm/attachments.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  # A module for handling attachments and file operations in RubyLLM.
+  module Attachments
+    # Base class for attachments
+    class Base
+      attr_reader :source, :filename
+
+      def initialize(source, filename: nil)
+        @source = source
+        @filename = filename ||
+                    (@source.respond_to?(:original_filename) && @source.original_filename) ||
+                    (@source.respond_to?(:path) && File.basename(@source.path)) ||
+                    (@source.is_a?(String) && File.basename(@source.split('?').first)) || # Basic URL basename
+                    nil
+      end
+
+      def url?
+        @source.is_a?(String) && @source.match?(%r{^https?://})
+      end
+
+      def file_path?
+        @source.is_a?(String) && !url?
+      end
+
+      def io_like?
+        @source.respond_to?(:read) && !file_path?
+      end
+
+      def content
+        return @content if defined?(@content) && !@content.nil?
+
+        if url?
+          fetch_content
+        elsif file_path?
+          load_content_from_path
+        elsif io_like?
+          load_content_from_io
+        else
+          RubyLLM.logger.warn "Attachment source is neither a String nor an IO-like object: #{@source}"
+          nil
+        end
+
+        @content
+      end
+
+      def type
+        self.class.name.demodulize.downcase
+      end
+
+      def encoded
+        Base64.strict_encode64(content)
+      end
+
+      def mime_type
+        RubyLLM::MimeTypes.detect_from_path(@filename)
+      end
+
+      private
+
+      def fetch_content
+        RubyLLM.logger.debug("Fetching content from URL: #{@source}")
+        response = Faraday.get(@source)
+        @content = response.body if response.success?
+      end
+
+      def load_content_from_path
+        @content = File.read(File.expand_path(@source))
+      end
+
+      def load_content_from_io
+        @source.rewind if source.respond_to? :rewind
+        @content = @source.read
+      end
+    end
+  end
+end

data/lib/ruby_llm/chat.rb

@@ -8,18 +8,20 @@ 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
+      config = context&.config || RubyLLM.config
+      model_id = model || config.default_model
       with_model(model_id, provider: provider, assume_exists: assume_model_exists)
+      @connection = context ? context.connection_for(@provider) : @provider.connection(config)
       @temperature = 0.7
       @messages = []
       @tools = {}
@@ -29,9 +31,9 @@ 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
@@ -44,7 +46,7 @@ module RubyLLM
     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,8 @@ 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:)
       self
     end
 
@@ -94,7 +86,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 +110,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,10 @@ module RubyLLM
                   :max_retries,
                   :retry_interval,
                   :retry_backoff_factor,
-                  :retry_interval_randomness
+                  :retry_interval_randomness,
+                  # Logging configuration
+                  :log_file,
+                  :log_level
 
     def initialize
       # Connection configuration
@@ -43,6 +50,28 @@ module RubyLLM
       @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
+    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,95 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  # Connection class for managing API connections to various providers.
+  class Connection
+    attr_reader :provider, :connection, :config
+
+    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)
+      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 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

data/lib/ruby_llm/content.rb

@@ -5,100 +5,79 @@ module RubyLLM
   # Stores data in a standard internal format, letting providers
   # handle their own formatting needs.
   class Content
-    def initialize(text = nil, attachments = {}) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-      @parts = []
-      @parts << { type: 'text', text: text } unless text.nil? || text.empty?
+    attr_reader :text, :attachments
 
-      Array(attachments[:image]).each do |source|
-        @parts << attach_image(source)
-      end
+    def initialize(text = nil, attachments = nil)
+      @text = text
+      @attachments = []
 
-      Array(attachments[:audio]).each do |source|
-        @parts << attach_audio(source)
-      end
+      process_attachments(attachments)
+      raise ArgumentError, 'Text and attachments cannot be both nil' if @text.nil? && @attachments.empty?
+    end
 
-      Array(attachments[:pdf]).each do |source|
-        @parts << attach_pdf(source)
-      end
+    def add_image(source)
+      @attachments << Attachments::Image.new(source)
+      self
     end
 
-    def to_a
-      return if @parts.empty?
+    def add_audio(source)
+      @attachments << Attachments::Audio.new(source)
+      self
+    end
 
-      @parts
+    def add_pdf(source)
+      @attachments << Attachments::PDF.new(source)
+      self
     end
 
     def format
-      return @parts.first[:text] if @parts.size == 1 && @parts.first[:type] == 'text'
+      if @text && @attachments.empty?
+        @text
+      else
+        self
+      end
+    end
 
-      to_a
+    # For Rails serialization
+    def as_json
+      hash = { text: @text }
+      unless @attachments.empty?
+        hash[:attachments] = @attachments.map do |a|
+          { type: a.type, source: a.source }
+        end
+      end
+      hash
     end
 
     private
 
-    def attach_image(source) # rubocop:disable Metrics/MethodLength
-      source = File.expand_path(source) unless source.start_with?('http')
-
-      return { type: 'image', source: { url: source } } if source.start_with?('http')
+    def process_attachments_hash(attachments)
+      return unless attachments.is_a?(Hash)
 
-      data = Base64.strict_encode64(File.read(source))
-      mime_type = mime_type_for(source)
-
-      {
-        type: 'image',
-        source: {
-          type: 'base64',
-          media_type: mime_type,
-          data: data
-        }
-      }
+      Array(attachments[:image]).each { |source| add_image(source) }
+      Array(attachments[:audio]).each { |source| add_audio(source) }
+      Array(attachments[:pdf]).each { |source| add_pdf(source) }
     end
 
-    def attach_audio(source)
-      source = File.expand_path(source) unless source.start_with?('http')
-      data = encode_file(source)
-      format = File.extname(source).delete('.') || 'wav'
-
-      {
-        type: 'input_audio',
-        input_audio: {
-          data: data,
-          format: format
-        }
-      }
-    end
-
-    def attach_pdf(source)
-      source = File.expand_path(source) unless source.start_with?('http')
-
-      pdf_data = {
-        type: 'pdf',
-        source: source
-      }
-
-      # For local files, validate they exist
-      unless source.start_with?('http')
-        raise Error, "PDF file not found: #{source}" unless File.exist?(source)
-
-        # Preload file content for providers that need it
-        pdf_data[:content] = File.read(source)
+    def process_attachments_array_or_string(attachments)
+      Array(attachments).each do |file|
+        mime_type = RubyLLM::MimeTypes.detect_from_path(file.to_s)
+        if RubyLLM::MimeTypes.image?(mime_type)
+          add_image file
+        elsif RubyLLM::MimeTypes.audio?(mime_type)
+          add_audio file
+        else
+          add_pdf file # Default to PDF for unknown types for now
+        end
       end
-
-      pdf_data
     end
 
-    def encode_file(source)
-      if source.start_with?('http')
-        response = Faraday.get(source)
-        Base64.strict_encode64(response.body)
+    def process_attachments(attachments)
+      if attachments.is_a?(Hash)
+        process_attachments_hash attachments
       else
-        Base64.strict_encode64(File.read(source))
+        process_attachments_array_or_string attachments
       end
     end
-
-    def mime_type_for(path)
-      ext = File.extname(path).delete('.')
-      "image/#{ext}"
-    end
   end
 end

data/lib/ruby_llm/context.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  # Holds per-call configs
+  class Context
+    attr_reader :config
+
+    def initialize(config)
+      @config = config
+      @connections = {}
+    end
+
+    def chat(*args, **kwargs, &)
+      Chat.new(*args, **kwargs, context: self, &)
+    end
+
+    def embed(*args, **kwargs, &)
+      Embedding.embed(*args, **kwargs, context: self, &)
+    end
+
+    def paint(*args, **kwargs, &)
+      Image.paint(*args, **kwargs, context: self, &)
+    end
+
+    def connection_for(provider_module)
+      slug = provider_module.slug.to_sym
+      @connections[slug] ||= Connection.new(provider_module, @config)
+    end
+  end
+end

data/lib/ruby_llm/embedding.rb

@@ -12,12 +12,20 @@ module RubyLLM
       @input_tokens = input_tokens
     end
 
-    def self.embed(text, model: nil)
-      model_id = model || RubyLLM.config.default_embedding_model
-      Models.find(model_id)
+    def self.embed(text, # rubocop:disable Metrics/ParameterLists
+                   model: nil,
+                   provider: nil,
+                   assume_model_exists: false,
+                   context: nil,
+                   dimensions: nil)
+      config = context&.config || RubyLLM.config
+      model ||= config.default_embedding_model
+      model, provider = Models.resolve(model, provider: provider, assume_exists: assume_model_exists)
+      model_id = model.id
 
-      provider = Provider.for(model_id)
-      provider.embed(text, model: model_id)
+      provider = Provider.for(model_id) if provider.nil?
+      connection = context ? context.connection_for(provider) : provider.connection(config)
+      provider.embed(text, model: model_id, connection:, dimensions:)
     end
   end
 end

data/lib/ruby_llm/error.rb

@@ -50,7 +50,7 @@ module RubyLLM
     end
 
     class << self
-      def parse_error(provider:, response:) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/AbcSize,Metrics/PerceivedComplexity
+      def parse_error(provider:, response:) # rubocop:disable Metrics/PerceivedComplexity
         message = provider&.parse_error(response)
 
         case response.status

data/lib/ruby_llm/image.rb

@@ -36,12 +36,20 @@ module RubyLLM
       path
     end
 
-    def self.paint(prompt, model: nil, size: '1024x1024')
-      model_id = model || RubyLLM.config.default_image_model
-      Models.find(model_id) # Validate model exists
+    def self.paint(prompt, # rubocop:disable Metrics/ParameterLists
+                   model: nil,
+                   provider: nil,
+                   assume_model_exists: false,
+                   size: '1024x1024',
+                   context: nil)
+      config = context&.config || RubyLLM.config
+      model ||= config.default_image_model
+      model, provider = Models.resolve(model, provider: provider, assume_exists: assume_model_exists)
+      model_id = model.id
 
-      provider = Provider.for(model_id)
-      provider.paint(prompt, model: model_id, size: size)
+      provider = Provider.for(model_id) if provider.nil?
+      connection = context ? context.connection_for(provider) : provider.connection(config)
+      provider.paint(prompt, model: model_id, size:, connection:)
     end
   end
 end