ruby_llm 1.1.2 → 1.3.0rc1

data/lib/ruby_llm/models.rb

@@ -12,7 +12,6 @@ module RubyLLM
   class Models
     include Enumerable
 
-    # Delegate class methods to the singleton instance
     class << self
       def instance
         @instance ||= new
@@ -26,21 +25,48 @@ module RubyLLM
         File.expand_path('models.json', __dir__)
       end
 
-      def refresh! # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
-        configured = Provider.configured_providers
+      def refresh!
+        # Collect models from both sources
+        provider_models = fetch_from_providers
+        parsera_models = fetch_from_parsera
 
-        # Log provider status
-        skipped = Provider.providers.values - configured
-        RubyLLM.logger.info "Refreshing models from #{configured.map(&:slug).join(', ')}" if configured.any?
-        RubyLLM.logger.info "Skipping #{skipped.map(&:slug).join(', ')} - providers not configured" if skipped.any?
+        # Merge with parsera data taking precedence
+        merged_models = merge_models(provider_models, parsera_models)
 
-        # Store current models except from configured providers
-        current = instance.load_models
-        preserved = current.reject { |m| configured.map(&:slug).include?(m.provider) }
+        @instance = new(merged_models)
+      end
+
+      def fetch_from_providers
+        configured = Provider.configured_providers(RubyLLM.config).filter(&:remote?)
+
+        RubyLLM.logger.info "Fetching models from providers: #{configured.map(&:slug).join(', ')}"
 
-        all = (preserved + configured.flat_map(&:list_models)).sort_by(&:id)
-        @instance = new(all)
-        @instance
+        configured.flat_map do |provider|
+          provider.list_models(connection: provider.connection(RubyLLM.config))
+        end
+      end
+
+      def resolve(model_id, provider: nil, assume_exists: false)
+        assume_exists = true if provider && Provider.providers[provider.to_sym].local?
+
+        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, :capabilities, :modalities, :supports_vision?, :supports_functions?)
+                        .new(model_id,
+                             provider,
+                             %w[function_calling streaming],
+                             RubyLLM::Modalities.new({ input: %w[text image], output: %w[text] }),
+                             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
+        [model, provider]
       end
 
       def method_missing(method, ...)
@@ -54,6 +80,61 @@ module RubyLLM
       def respond_to_missing?(method, include_private = false)
         instance.respond_to?(method, include_private) || super
       end
+
+      def fetch_from_parsera
+        RubyLLM.logger.info 'Fetching models from Parsera API...'
+
+        connection = Faraday.new('https://api.parsera.org') do |f|
+          f.request :json
+          f.response :json
+          f.response :raise_error
+          f.adapter Faraday.default_adapter
+        end
+
+        response = connection.get('/v1/llm-specs')
+        response.body.map { |data| ModelInfo.new(Utils.deep_symbolize_keys(data)) }
+      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
+
+        models.sort_by { |m| [m.provider, m.id] }
+      end
+
+      def index_by_key(models)
+        models.each_with_object({}) do |model, hash|
+          hash["#{model.provider}:#{model.id}"] = model
+        end
+      end
+
+      def add_provider_metadata(parsera_model, provider_model)
+        # Create a new ModelInfo with parsera data but include provider metadata
+        data = parsera_model.to_h
+        data[:metadata] = provider_model.metadata.merge(data[:metadata] || {})
+        ModelInfo.new(data)
+      end
     end
 
     # Initialize with optional pre-filtered models
@@ -64,7 +145,7 @@ module RubyLLM
     # 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).map { |model| ModelInfo.new(model.transform_keys(&:to_sym)) }
+      JSON.parse(data).map { |model| ModelInfo.new(Utils.deep_symbolize_keys(model)) }
     rescue JSON::ParserError
       []
     end

data/lib/ruby_llm/provider.rb

@@ -7,15 +7,11 @@ module RubyLLM
   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 # rubocop:disable Metrics/ModuleLength
+    module Methods
       extend Streaming
 
-      def complete(messages, tools:, temperature:, model:, &block) # rubocop:disable Metrics/MethodLength
-        normalized_temperature = if capabilities.respond_to?(:normalize_temperature)
-                                   capabilities.normalize_temperature(temperature, model)
-                                 else
-                                   temperature
-                                 end
+      def complete(messages, tools:, temperature:, model:, connection:, &)
+        normalized_temperature = maybe_normalize_temperature(temperature, model)
 
         payload = render_payload(messages,
                                  tools: tools,
@@ -24,112 +20,62 @@ module RubyLLM
                                  stream: block_given?)
 
         if block_given?
-          stream_response payload, &block
+          stream_response connection, payload, &
         else
-          sync_response payload
+          sync_response connection, payload
         end
       end
 
-      def list_models
-        response = connection.get(models_url) do |req|
-          req.headers.merge! headers
-        end
-
+      def list_models(connection:)
+        response = connection.get models_url
         parse_list_models_response response, slug, capabilities
       end
 
-      def embed(text, model:)
-        payload = render_embedding_payload text, model: model
-        response = post embedding_url, payload
-        parse_embedding_response response
+      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:)
       end
 
-      def paint(prompt, model:, size:)
+      def paint(prompt, model:, size:, connection:)
         payload = render_image_payload(prompt, model:, size:)
-
-        response = post(images_url, payload)
-        parse_image_response(response)
+        response = connection.post images_url, payload
+        parse_image_response response
       end
 
-      def configured?
-        missing_configs.empty?
+      def configured?(config = nil)
+        config ||= RubyLLM.config
+        missing_configs(config).empty?
       end
 
-      private
-
-      def missing_configs
+      def missing_configs(config)
         configuration_requirements.select do |key|
-          value = RubyLLM.config.send(key)
+          value = config.send(key)
           value.nil? || value.empty?
         end
       end
 
-      def ensure_configured!
-        return if configured?
-
-        config_block = <<~RUBY
-          RubyLLM.configure do |config|
-            #{missing_configs.map { |key| "config.#{key} = ENV['#{key.to_s.upcase}']" }.join("\n  ")}
-          end
-        RUBY
-
-        raise ConfigurationError,
-              "#{slug} provider is not configured. Add this to your initialization:\n\n#{config_block}"
+      def local?
+        false
       end
 
-      def sync_response(payload)
-        response = post completion_url, payload
-        parse_completion_response response
+      def remote?
+        !local?
       end
 
-      def post(url, payload)
-        connection.post url, payload do |req|
-          req.headers.merge! headers
-          yield req if block_given?
+      private
+
+      def maybe_normalize_temperature(temperature, model)
+        if capabilities.respond_to?(:normalize_temperature)
+          capabilities.normalize_temperature(temperature, model)
+        else
+          temperature
         end
       end
 
-      def connection # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
-        ensure_configured!
-
-        @connection ||= Faraday.new(api_base) do |f| # rubocop:disable Metrics/BlockLength
-          f.options.timeout = RubyLLM.config.request_timeout
-
-          f.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
-
-          f.request :retry, {
-            max: RubyLLM.config.max_retries,
-            interval: RubyLLM.config.retry_interval,
-            interval_randomness: RubyLLM.config.retry_interval_randomness,
-            backoff_factor: RubyLLM.config.retry_backoff_factor,
-            exceptions: [
-              Errno::ETIMEDOUT,
-              Timeout::Error,
-              Faraday::TimeoutError,
-              Faraday::ConnectionFailed,
-              Faraday::RetriableResponse,
-              RubyLLM::RateLimitError,
-              RubyLLM::ServerError,
-              RubyLLM::ServiceUnavailableError,
-              RubyLLM::OverloadedError
-            ],
-            retry_statuses: [429, 500, 502, 503, 504, 529]
-          }
-
-          f.request :json
-          f.response :json
-          f.adapter Faraday.default_adapter
-          f.use :llm_errors, provider: self
-        end
+      def sync_response(connection, payload)
+        response = connection.post completion_url, payload
+        parse_completion_response response
       end
     end
 
@@ -141,7 +87,7 @@ module RubyLLM
       maybe_json
     end
 
-    def parse_error(response) # rubocop:disable Metrics/MethodLength
+    def parse_error(response)
       return if response.body.empty?
 
       body = try_parse_json(response.body)
@@ -167,6 +113,10 @@ module RubyLLM
       nil
     end
 
+    def connection(config)
+      @connection ||= Connection.new(self, config)
+    end
+
     class << self
       def extended(base)
         base.extend(Methods)
@@ -186,8 +136,16 @@ module RubyLLM
         @providers ||= {}
       end
 
-      def configured_providers
-        providers.select { |_name, provider| provider.configured? }.values
+      def local_providers
+        providers.select { |_slug, provider| provider.local? }
+      end
+
+      def remote_providers
+        providers.select { |_slug, provider| provider.remote? }
+      end
+
+      def configured_providers(config = nil)
+        providers.select { |_slug, provider| provider.configured?(config) }.values
       end
     end
   end

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

@@ -73,13 +73,13 @@ module RubyLLM
         # @return [Symbol] the model family identifier
         def model_family(model_id)
           case model_id
-          when /claude-3-7-sonnet/  then :claude37_sonnet
-          when /claude-3-5-sonnet/  then :claude35_sonnet
-          when /claude-3-5-haiku/   then :claude35_haiku
-          when /claude-3-opus/      then :claude3_opus
-          when /claude-3-sonnet/    then :claude3_sonnet
-          when /claude-3-haiku/     then :claude3_haiku
-          else :claude2
+          when /claude-3-7-sonnet/  then 'claude-3-7-sonnet'
+          when /claude-3-5-sonnet/  then 'claude-3-5-sonnet'
+          when /claude-3-5-haiku/   then 'claude-3-5-haiku'
+          when /claude-3-opus/      then 'claude-3-opus'
+          when /claude-3-sonnet/    then 'claude-3-sonnet'
+          when /claude-3-haiku/     then 'claude-3-haiku'
+          else 'claude-2'
           end
         end
 
@@ -92,12 +92,12 @@ module RubyLLM
 
         # Pricing information for Anthropic models (per million tokens)
         PRICES = {
-          claude37_sonnet: { input: 3.0, output: 15.0 },
-          claude35_sonnet: { input: 3.0, output: 15.0 },
-          claude35_haiku: { input: 0.80, output: 4.0 },
-          claude3_opus: { input: 15.0, output: 75.0 },
-          claude3_haiku: { input: 0.25, output: 1.25 },
-          claude2: { input: 3.0, output: 15.0 }
+          'claude-3-7-sonnet': { input: 3.0, output: 15.0 },
+          'claude-3-5-sonnet': { input: 3.0, output: 15.0 },
+          'claude-3-5-haiku': { input: 0.80, output: 4.0 },
+          'claude-3-opus': { input: 15.0, output: 75.0 },
+          'claude-3-haiku': { input: 0.25, output: 1.25 },
+          'claude-2': { input: 3.0, output: 15.0 }
         }.freeze
 
         # Default input price if model not found in PRICES
@@ -111,6 +111,69 @@ module RubyLLM
         def default_output_price
           15.0
         end
+
+        def modalities_for(model_id)
+          modalities = {
+            input: ['text'],
+            output: ['text']
+          }
+
+          # All Claude 3+ models support vision
+          unless model_id.match?(/claude-[12]/)
+            modalities[:input] << 'image'
+            modalities[:input] << 'pdf'
+          end
+
+          modalities
+        end
+
+        def capabilities_for(model_id)
+          capabilities = ['streaming']
+
+          # Function calling for Claude 3+
+          if model_id.match?(/claude-3/)
+            capabilities << 'function_calling'
+            capabilities << 'structured_output'
+            capabilities << 'batch'
+          end
+
+          # Extended thinking (reasoning) for Claude 3.7
+          capabilities << 'reasoning' if model_id.match?(/claude-3-7/)
+
+          # Citations
+          capabilities << 'citations' if model_id.match?(/claude-3\.5|claude-3-7/)
+
+          capabilities
+        end
+
+        def pricing_for(model_id)
+          family = model_family(model_id)
+          prices = PRICES.fetch(family.to_sym, { input: default_input_price, output: default_output_price })
+
+          standard_pricing = {
+            input_per_million: prices[:input],
+            output_per_million: prices[:output]
+          }
+
+          # Batch is typically half the price
+          batch_pricing = {
+            input_per_million: prices[:input] * 0.5,
+            output_per_million: prices[:output] * 0.5
+          }
+
+          # Add reasoning output pricing for 3.7 models
+          if model_id.match?(/claude-3-7/)
+            standard_pricing[:reasoning_output_per_million] = prices[:output] * 2.5
+            batch_pricing[:reasoning_output_per_million] = prices[:output] * 1.25
+          end
+
+          {
+            text_tokens: {
+              standard: standard_pricing,
+              batch: batch_pricing
+            }
+          }
+        end
       end
     end
   end

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

@@ -5,7 +5,7 @@ module RubyLLM
     module Anthropic
       # Chat methods of the OpenAI API integration
       module Chat
-        private
+        module_function
 
         def completion_url
           '/v1/messages'
@@ -41,12 +41,12 @@ module RubyLLM
             messages: chat_messages.map { |msg| format_message(msg) },
             temperature: temperature,
             stream: stream,
-            max_tokens: RubyLLM.models.find(model).max_tokens
+            max_tokens: RubyLLM.models.find(model)&.max_tokens || 4096
           }
         end
 
         def add_optional_fields(payload, system_content:, tools:)
-          payload[:tools] = tools.values.map { |t| function_for(t) } if tools.any?
+          payload[:tools] = tools.values.map { |t| Tools.function_for(t) } if tools.any?
           payload[:system] = system_content unless system_content.empty?
         end
 
@@ -55,7 +55,7 @@ module RubyLLM
           content_blocks = data['content'] || []
 
           text_content = extract_text_content(content_blocks)
-          tool_use = find_tool_use(content_blocks)
+          tool_use = Tools.find_tool_use(content_blocks)
 
           build_message(data, text_content, tool_use)
         end
@@ -69,7 +69,7 @@ module RubyLLM
           Message.new(
             role: :assistant,
             content: content,
-            tool_calls: parse_tool_calls(tool_use),
+            tool_calls: Tools.parse_tool_calls(tool_use),
             input_tokens: data.dig('usage', 'input_tokens'),
             output_tokens: data.dig('usage', 'output_tokens'),
             model_id: data['model']
@@ -78,9 +78,9 @@ module RubyLLM
 
         def format_message(msg)
           if msg.tool_call?
-            format_tool_call(msg)
+            Tools.format_tool_call(msg)
           elsif msg.tool_result?
-            format_tool_result(msg)
+            Tools.format_tool_result(msg)
           else
             format_basic_message(msg)
           end
@@ -99,13 +99,6 @@ module RubyLLM
           else 'assistant'
           end
         end
-
-        def format_text_block(content)
-          {
-            type: 'text',
-            text: content
-          }
-        end
       end
     end
   end

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

@@ -7,62 +7,72 @@ module RubyLLM
       module Media
         module_function
 
-        def format_content(content) # rubocop:disable Metrics/MethodLength
-          return content unless content.is_a?(Array)
+        def format_content(content)
+          return [format_text(content)] unless content.is_a?(Content)
 
-          content.map do |part|
-            case part[:type]
-            when 'image'
-              format_image(part)
-            when 'pdf'
-              format_pdf(part)
-            when 'text'
-              format_text_block(part[:text])
-            else
-              part
+          parts = []
+          parts << format_text(content.text) if content.text
+
+          content.attachments.each do |attachment|
+            case attachment
+            when Attachments::Image
+              parts << format_image(attachment)
+            when Attachments::PDF
+              parts << format_pdf(attachment)
             end
           end
+
+          parts
         end
 
-        def format_image(part)
-          # Handle image formatting for Anthropic
-          # This is just a placeholder - implement based on Anthropic's requirements
-          part
+        def format_text(text)
+          {
+            type: 'text',
+            text: text
+          }
         end
 
-        def format_pdf(part) # rubocop:disable Metrics/MethodLength
-          source = part[:source]
+        def format_image(image)
+          if image.url?
+            {
+              type: 'image',
+              source: {
+                type: 'url',
+                url: image.source
+              }
+            }
+          else
+            {
+              type: 'image',
+              source: {
+                type: 'base64',
+                media_type: image.mime_type,
+                data: image.encoded
+              }
+            }
+          end
+        end
 
-          if source.start_with?('http')
-            # For URLs - add "type": "url" here
+        def format_pdf(pdf)
+          if pdf.url?
             {
               type: 'document',
               source: {
-                type: 'url', # This line is missing in the current implementation
-                url: source
+                type: 'url',
+                url: pdf.source
               }
             }
           else
-            # For local files
-            data = Base64.strict_encode64(part[:content])
-
             {
               type: 'document',
               source: {
                 type: 'base64',
-                media_type: 'application/pdf',
-                data: data
+                media_type: pdf.mime_type,
+                data: pdf.encoded
               }
             }
           end
         end
-
-        def format_text_block(text)
-          {
-            type: 'text',
-            text: text
-          }
-        end
       end
     end
   end

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

@@ -5,28 +5,28 @@ module RubyLLM
     module Anthropic
       # Models methods of the Anthropic API integration
       module Models
-        private
+        module_function
 
         def models_url
           '/v1/models'
         end
 
-        def parse_list_models_response(response, slug, capabilities) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-          (response.body['data'] || []).map do |model|
+        def parse_list_models_response(response, slug, capabilities)
+          Array(response.body['data']).map do |model_data|
+            model_id = model_data['id']
+
             ModelInfo.new(
-              id: model['id'],
-              created_at: Time.parse(model['created_at']),
-              display_name: model['display_name'],
+              id: model_id,
+              name: model_data['display_name'],
               provider: slug,
-              type: capabilities.model_type(model['id']),
-              family: capabilities.model_family(model['id']),
-              context_window: capabilities.determine_context_window(model['id']),
-              max_tokens: capabilities.determine_max_tokens(model['id']),
-              supports_vision: capabilities.supports_vision?(model['id']),
-              supports_functions: capabilities.supports_functions?(model['id']),
-              supports_json_mode: capabilities.supports_json_mode?(model['id']),
-              input_price_per_million: capabilities.get_input_price(model['id']),
-              output_price_per_million: capabilities.get_output_price(model['id'])
+              family: capabilities.model_family(model_id),
+              created_at: Time.parse(model_data['created_at']),
+              context_window: capabilities.determine_context_window(model_id),
+              max_output_tokens: capabilities.determine_max_tokens(model_id),
+              modalities: capabilities.modalities_for(model_id),
+              capabilities: capabilities.capabilities_for(model_id),
+              pricing: capabilities.pricing_for(model_id),
+              metadata: {}
             )
           end
         end

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

@@ -5,7 +5,7 @@ module RubyLLM
     module Anthropic
       # Tools methods of the Anthropic API integration
       module Tools
-        private
+        module_function
 
         def find_tool_use(blocks)
           blocks.find { |c| c['type'] == 'tool_use' }
@@ -17,7 +17,7 @@ module RubyLLM
           {
             role: 'assistant',
             content: [
-              format_text_block(msg.content),
+              Media.format_text(msg.content),
               format_tool_use_block(tool_call)
             ]
           }