ruby_llm 1.5.1 → 1.6.0

data/lib/ruby_llm/models.rb

@@ -37,26 +37,35 @@ module RubyLLM
       end
 
       def fetch_from_providers
-        configured = Provider.configured_providers(RubyLLM.config).filter(&:remote?)
+        config = RubyLLM.config
+        configured_classes = Provider.configured_remote_providers(config)
+        configured = configured_classes.map { |klass| klass.new(config) }
 
-        RubyLLM.logger.info "Fetching models from providers: #{configured.map(&:slug).join(', ')}"
+        RubyLLM.logger.info "Fetching models from providers: #{configured.map(&:name).join(', ')}"
 
-        configured.flat_map do |provider|
-          provider.list_models(connection: provider.connection(RubyLLM.config))
-        end
+        configured.flat_map(&:list_models)
       end
 
-      def resolve(model_id, provider: nil, assume_exists: false) # rubocop:disable Metrics/PerceivedComplexity
-        assume_exists = true if provider && Provider.providers[provider.to_sym].local?
+      def resolve(model_id, provider: nil, assume_exists: false, config: nil) # rubocop:disable Metrics/PerceivedComplexity
+        config ||= RubyLLM.config
+        provider_class = provider ? Provider.providers[provider.to_sym] : nil
+
+        # Check if provider is local
+        if provider_class
+          temp_instance = provider_class.new(config)
+          assume_exists = true if temp_instance.local?
+        end
 
         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}")
+          provider_class ||= raise(Error, "Unknown provider: #{provider.to_sym}")
+          provider_instance = provider_class.new(config)
+
           model = Model::Info.new(
             id: model_id,
             name: model_id.gsub('-', ' ').capitalize,
-            provider: provider.slug,
+            provider: provider_instance.slug,
             capabilities: %w[function_calling streaming],
             modalities: { input: %w[text image], output: %w[text] },
             metadata: { warning: 'Assuming model exists, capabilities may not be accurate' }
@@ -67,9 +76,11 @@ module RubyLLM
           end
         else
           model = Models.find model_id, provider
-          provider = Provider.providers[model.provider.to_sym] || raise(Error, "Unknown provider: #{model.provider}")
+          provider_class = Provider.providers[model.provider.to_sym] || raise(Error,
+                                                                              "Unknown provider: #{model.provider}")
+          provider_instance = provider_class.new(config)
         end
-        [model, provider]
+        [model, provider_instance]
       end
 
       def method_missing(method, ...)
@@ -97,26 +108,19 @@ module RubyLLM
       end
 
       def merge_models(provider_models, parsera_models)
-        # Create lookups for both sets of models
         parsera_by_key = index_by_key(parsera_models)
         provider_by_key = index_by_key(provider_models)
 
-        # All keys from both sources
         all_keys = parsera_by_key.keys | provider_by_key.keys
 
-        # Merge data, with parsera taking precedence
         models = all_keys.map do |key|
           if (parsera_model = parsera_by_key[key])
-            # Parsera has this model - use it as the base
             if (provider_model = provider_by_key[key])
-              # Both sources have this model, add provider metadata
               add_provider_metadata(parsera_model, provider_model)
             else
-              # Only parsera has this model
               parsera_model
             end
           else
-            # Only provider has this model
             provider_by_key[key]
           end
         end
@@ -131,19 +135,16 @@ module RubyLLM
       end
 
       def add_provider_metadata(parsera_model, provider_model)
-        # Create a new Model::Info with parsera data but include provider metadata
         data = parsera_model.to_h
         data[:metadata] = provider_model.metadata.merge(data[:metadata] || {})
         Model::Info.new(data)
       end
     end
 
-    # Initialize with optional pre-filtered models
     def initialize(models = nil)
       @models = models || load_models
     end
 
-    # Load models from the JSON file
     def load_models
       data = File.exist?(self.class.models_file) ? File.read(self.class.models_file) : '[]'
       JSON.parse(data, symbolize_names: true).map { |model| Model::Info.new(model) }
@@ -155,17 +156,14 @@ module RubyLLM
       File.write(self.class.models_file, JSON.pretty_generate(all.map(&:to_h)))
     end
 
-    # Return all models in the collection
     def all
       @models
     end
 
-    # Allow enumeration over all models
     def each(&)
       all.each(&)
     end
 
-    # Find a specific model by ID
     def find(model_id, provider = nil)
       if provider
         find_with_provider(model_id, provider)
@@ -174,37 +172,30 @@ module RubyLLM
       end
     end
 
-    # Filter to only chat models
     def chat_models
       self.class.new(all.select { |m| m.type == 'chat' })
     end
 
-    # Filter to only embedding models
     def embedding_models
       self.class.new(all.select { |m| m.type == 'embedding' })
     end
 
-    # Filter to only audio models
     def audio_models
       self.class.new(all.select { |m| m.type == 'audio' })
     end
 
-    # Filter to only image models
     def image_models
       self.class.new(all.select { |m| m.type == 'image' })
     end
 
-    # Filter models by family
     def by_family(family)
       self.class.new(all.select { |m| m.family == family.to_s })
     end
 
-    # Filter models by provider
     def by_provider(provider)
       self.class.new(all.select { |m| m.provider == provider.to_s })
     end
 
-    # Instance method to refresh models
     def refresh!
       self.class.refresh!
     end

data/lib/ruby_llm/provider.rb

@@ -1,96 +1,94 @@
 # frozen_string_literal: true
 
 module RubyLLM
-  # Base interface for LLM providers like OpenAI and Anthropic.
+  # Base class for LLM providers like OpenAI and Anthropic.
   # Handles the complexities of API communication, streaming responses,
   # and error handling so individual providers can focus on their unique features.
-  module Provider
-    # Common functionality for all LLM providers. Implements the core provider
-    # interface so specific providers only need to implement a few key methods.
-    module Methods
-      extend Streaming
-
-      def complete(messages, tools:, temperature:, model:, connection:, params: {}, schema: nil, &) # rubocop:disable Metrics/ParameterLists
-        normalized_temperature = maybe_normalize_temperature(temperature, model)
-
-        payload = Utils.deep_merge(
-          params,
-          render_payload(
-            messages,
-            tools: tools,
-            temperature: normalized_temperature,
-            model: model,
-            stream: block_given?,
-            schema: schema
-          )
-        )
+  # Encapsulates configuration and connection to eliminate parameter threading.
+  class Provider
+    include Streaming
 
-        if block_given?
-          stream_response connection, payload, &
-        else
-          sync_response connection, payload
-        end
-      end
+    attr_reader :config, :connection
 
-      def list_models(connection:)
-        response = connection.get models_url
-        parse_list_models_response response, slug, capabilities
-      end
+    def initialize(config)
+      @config = config
+      ensure_configured!
+      @connection = Connection.new(self, @config)
+    end
 
-      def embed(text, model:, connection:, dimensions:)
-        payload = render_embedding_payload(text, model:, dimensions:)
-        response = connection.post(embedding_url(model:), payload)
-        parse_embedding_response(response, model:, text:)
-      end
+    def api_base
+      raise NotImplementedError
+    end
 
-      def paint(prompt, model:, size:, connection:)
-        payload = render_image_payload(prompt, model:, size:)
-        response = connection.post images_url, payload
-        parse_image_response(response, model:)
-      end
+    def headers
+      {}
+    end
 
-      def configured?(config = nil)
-        config ||= RubyLLM.config
-        missing_configs(config).empty?
-      end
+    def slug
+      self.class.slug
+    end
 
-      def missing_configs(config)
-        configuration_requirements.select do |key|
-          value = config.send(key)
-          value.nil? || value.empty?
-        end
-      end
+    def name
+      self.class.name
+    end
 
-      def local?
-        false
-      end
+    def capabilities
+      self.class.capabilities
+    end
 
-      def remote?
-        !local?
-      end
+    def configuration_requirements
+      self.class.configuration_requirements
+    end
 
-      private
+    def complete(messages, tools:, temperature:, model:, params: {}, headers: {}, schema: nil, &) # rubocop:disable Metrics/ParameterLists
+      normalized_temperature = maybe_normalize_temperature(temperature, model)
+
+      payload = Utils.deep_merge(
+        params,
+        render_payload(
+          messages,
+          tools: tools,
+          temperature: normalized_temperature,
+          model: model,
+          stream: block_given?,
+          schema: schema
+        )
+      )
 
-      def maybe_normalize_temperature(temperature, model)
-        if capabilities.respond_to?(:normalize_temperature)
-          capabilities.normalize_temperature(temperature, model)
-        else
-          temperature
-        end
+      if block_given?
+        stream_response @connection, payload, headers, &
+      else
+        sync_response @connection, payload, headers
       end
+    end
 
-      def sync_response(connection, payload)
-        response = connection.post completion_url, payload
-        parse_completion_response response
-      end
+    def list_models
+      response = @connection.get models_url
+      parse_list_models_response response, slug, capabilities
     end
 
-    def try_parse_json(maybe_json)
-      return maybe_json unless maybe_json.is_a?(String)
+    def embed(text, model:, dimensions:)
+      payload = render_embedding_payload(text, model:, dimensions:)
+      response = @connection.post(embedding_url(model:), payload)
+      parse_embedding_response(response, model:, text:)
+    end
 
-      JSON.parse(maybe_json)
-    rescue JSON::ParserError
-      maybe_json
+    def paint(prompt, model:, size:)
+      payload = render_image_payload(prompt, model:, size:)
+      response = @connection.post images_url, payload
+      parse_image_response(response, model:)
+    end
+
+    def configured?
+      configuration_requirements.all? { |req| @config.send(req) }
+    end
+
+    def local?
+      self.class.local?
+    end
+
+    def remote?
+      self.class.remote?
     end
 
     def parse_error(response)
@@ -109,28 +107,54 @@ module RubyLLM
       end
     end
 
-    def parse_data_uri(uri)
-      if uri&.start_with?('data:')
-        match = uri.match(/\Adata:([^;]+);base64,(.+)\z/)
-        return { mime_type: match[1], data: match[2] } if match
+    def format_messages(messages)
+      messages.map do |msg|
+        {
+          role: msg.role.to_s,
+          content: msg.content
+        }
       end
+    end
 
-      # If it's not a data URI, return nil
+    def format_tool_calls(_tool_calls)
       nil
     end
 
-    def connection(config)
-      @connection ||= Connection.new(self, config)
+    def parse_tool_calls(_tool_calls)
+      nil
     end
 
     class << self
-      def extended(base)
-        base.extend(Methods)
-        base.extend(Streaming)
+      def name
+        to_s.split('::').last
+      end
+
+      def slug
+        name.downcase
+      end
+
+      def capabilities
+        raise NotImplementedError
+      end
+
+      def configuration_requirements
+        []
+      end
+
+      def local?
+        false
       end
 
-      def register(name, provider_module)
-        providers[name.to_sym] = provider_module
+      def remote?
+        !local?
+      end
+
+      def configured?(config)
+        configuration_requirements.all? { |req| config.send(req) }
+      end
+
+      def register(name, provider_class)
+        providers[name.to_sym] = provider_class
       end
 
       def for(model)
@@ -143,16 +167,53 @@ module RubyLLM
       end
 
       def local_providers
-        providers.select { |_slug, provider| provider.local? }
+        providers.select { |_slug, provider_class| provider_class.local? }
       end
 
       def remote_providers
-        providers.select { |_slug, provider| provider.remote? }
+        providers.select { |_slug, provider_class| provider_class.remote? }
+      end
+
+      def configured_providers(config)
+        providers.select do |_slug, provider_class|
+          provider_class.configured?(config)
+        end.values
+      end
+
+      def configured_remote_providers(config)
+        providers.select do |_slug, provider_class|
+          provider_class.remote? && provider_class.configured?(config)
+        end.values
       end
+    end
+
+    private
+
+    def try_parse_json(maybe_json)
+      return maybe_json unless maybe_json.is_a?(String)
+
+      JSON.parse(maybe_json)
+    rescue JSON::ParserError
+      maybe_json
+    end
+
+    def ensure_configured!
+      missing = configuration_requirements.reject { |req| @config.send(req) }
+      return if missing.empty?
+
+      raise ConfigurationError, "Missing configuration for #{name}: #{missing.join(', ')}"
+    end
+
+    def maybe_normalize_temperature(temperature, _model_id)
+      temperature
+    end
 
-      def configured_providers(config = nil)
-        providers.select { |_slug, provider| provider.configured?(config) }.values
+    def sync_response(connection, payload, additional_headers = {})
+      response = connection.post completion_url, payload do |req|
+        # Merge additional headers, with existing headers taking precedence
+        req.headers = additional_headers.merge(req.headers) unless additional_headers.empty?
       end
+      parse_completion_response response
     end
   end
 end

data/lib/ruby_llm/providers/anthropic/capabilities.rb

@@ -2,7 +2,7 @@
 
 module RubyLLM
   module Providers
-    module Anthropic
+    class Anthropic
       # Determines capabilities and pricing for Anthropic models
       module Capabilities
         module_function
@@ -133,7 +133,6 @@ module RubyLLM
           # Function calling for Claude 3+
           if model_id.match?(/claude-3/)
             capabilities << 'function_calling'
-            capabilities << 'structured_output'
             capabilities << 'batch'
           end
 

data/lib/ruby_llm/providers/anthropic/chat.rb

@@ -2,7 +2,7 @@
 
 module RubyLLM
   module Providers
-    module Anthropic
+    class Anthropic
       # Chat methods of the OpenAI API integration
       module Chat
         module_function

data/lib/ruby_llm/providers/anthropic/embeddings.rb

@@ -2,7 +2,7 @@
 
 module RubyLLM
   module Providers
-    module Anthropic
+    class Anthropic
       # Embeddings methods of the Anthropic API integration
       module Embeddings
         private

data/lib/ruby_llm/providers/anthropic/media.rb

@@ -2,7 +2,7 @@
 
 module RubyLLM
   module Providers
-    module Anthropic
+    class Anthropic
       # Handles formatting of media content (images, PDFs, audio) for Anthropic
       module Media
         module_function

data/lib/ruby_llm/providers/anthropic/models.rb

@@ -2,7 +2,7 @@
 
 module RubyLLM
   module Providers
-    module Anthropic
+    class Anthropic
       # Models methods of the Anthropic API integration
       module Models
         module_function

data/lib/ruby_llm/providers/anthropic/streaming.rb

@@ -2,7 +2,7 @@
 
 module RubyLLM
   module Providers
-    module Anthropic
+    class Anthropic
       # Streaming methods of the Anthropic API integration
       module Streaming
         private

data/lib/ruby_llm/providers/anthropic/tools.rb

@@ -2,7 +2,7 @@
 
 module RubyLLM
   module Providers
-    module Anthropic
+    class Anthropic
       # Tools methods of the Anthropic API integration
       module Tools
         module_function

data/lib/ruby_llm/providers/anthropic.rb

@@ -4,38 +4,33 @@ module RubyLLM
   module Providers
     # Anthropic Claude API integration. Handles the complexities of
     # Claude's unique message format and tool calling conventions.
-    module Anthropic
-      extend Provider
-      extend Anthropic::Chat
-      extend Anthropic::Embeddings
-      extend Anthropic::Media
-      extend Anthropic::Models
-      extend Anthropic::Streaming
-      extend Anthropic::Tools
+    class Anthropic < Provider
+      include Anthropic::Chat
+      include Anthropic::Embeddings
+      include Anthropic::Media
+      include Anthropic::Models
+      include Anthropic::Streaming
+      include Anthropic::Tools
 
-      module_function
-
-      def api_base(_config)
+      def api_base
         'https://api.anthropic.com'
       end
 
-      def headers(config)
+      def headers
         {
-          'x-api-key' => config.anthropic_api_key,
+          'x-api-key' => @config.anthropic_api_key,
           'anthropic-version' => '2023-06-01'
         }
       end
 
-      def capabilities
-        Anthropic::Capabilities
-      end
-
-      def slug
-        'anthropic'
-      end
+      class << self
+        def capabilities
+          Anthropic::Capabilities
+        end
 
-      def configuration_requirements
-        %i[anthropic_api_key]
+        def configuration_requirements
+          %i[anthropic_api_key]
+        end
       end
     end
   end