ruby_llm 1.16.0 → 2.0.0.rc4

data/lib/ruby_llm/aliases.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-
-module RubyLLM
-  # Manages model aliases for provider-specific versions
-  class Aliases
-    class << self
-      def resolve(model_id, provider = nil)
-        return model_id unless aliases[model_id]
-
-        if provider
-          aliases[model_id][provider.to_s] || model_id
-        else
-          aliases[model_id].values.first || model_id
-        end
-      end
-
-      def aliases
-        @aliases ||= load_aliases
-      end
-
-      def aliases_file
-        File.expand_path('aliases.json', __dir__)
-      end
-
-      def load_aliases
-        if File.exist?(aliases_file)
-          JSON.parse(File.read(aliases_file))
-        else
-          {}
-        end
-      end
-
-      # Replaces the cached alias map from aliases.json.
-      def reload!
-        @aliases = load_aliases
-      end
-    end
-  end
-end

data/lib/ruby_llm/connection.rb

@@ -1,159 +0,0 @@
-# frozen_string_literal: true
-
-require 'faraday'
-require 'faraday/multipart'
-require 'faraday/retry'
-require 'ruby_llm/error_middleware'
-require 'timeout'
-
-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,
-                   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) do |faraday|
-        setup_timeout(faraday)
-        setup_logging(faraday)
-        setup_retry(faraday)
-        setup_middleware(faraday)
-        setup_http_proxy(faraday)
-      end
-    end
-
-    def post(url, payload, &)
-      instrument_request(:post, url) do
-        @connection.post url, payload do |req|
-          req.headers.merge! provider_headers
-          yield req if block_given?
-        end
-      end
-    end
-
-    def get(url, &)
-      instrument_request(:get, url) do
-        @connection.get url do |req|
-          req.headers.merge! provider_headers
-          yield req if block_given?
-        end
-      end
-    end
-
-    def instance_variables
-      super - %i[@config @connection]
-    end
-
-    private
-
-    def provider_headers
-      @provider.respond_to?(:headers) ? @provider.headers : {}
-    end
-
-    def instrument_request(method, url)
-      payload = {
-        provider: @provider.respond_to?(:slug) ? @provider.slug : @provider.class.name,
-        method: method,
-        url: url
-      }
-
-      RubyLLM.instrument('request.ruby_llm', payload, config: @config) do
-        response = yield
-        payload[:status] = response.status if response.respond_to?(:status)
-        response
-      end
-    end
-
-    def setup_timeout(faraday)
-      faraday.options.timeout = @config.request_timeout
-    end
-
-    def setup_logging(faraday)
-      faraday.response :logger,
-                       RubyLLM.logger,
-                       bodies: RubyLLM.logger.debug?,
-                       errors: true,
-                       headers: false,
-                       log_level: :debug do |logger|
-        logger.filter(logging_regexp('[A-Za-z0-9+/=]{100,}'), '[BASE64 DATA]')
-        logger.filter(logging_regexp('[-\\d.e,\\s]{100,}'), '[EMBEDDINGS ARRAY]')
-      end
-    end
-
-    def logging_regexp(pattern)
-      return Regexp.new(pattern) if @config.log_regexp_timeout.nil? || !Regexp.respond_to?(:timeout)
-
-      Regexp.new(pattern, timeout: @config.log_regexp_timeout)
-    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,
-        methods: Faraday::Retry::Middleware::IDEMPOTENT_METHODS + [:post],
-        exceptions: retry_exceptions
-      }
-    end
-
-    def setup_middleware(faraday)
-      faraday.request :multipart
-      faraday.request :json
-      faraday.response :json
-      adapter = @config.respond_to?(:faraday_adapter) ? @config.faraday_adapter : :net_http
-      faraday.adapter(adapter || :net_http)
-      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?
-
-      missing = @provider.configuration_requirements.reject { |req| @config.send(req) }
-      config_block = <<~RUBY
-        RubyLLM.configure do |config|
-          #{missing.map { |key| "config.#{key} = ENV['#{key.to_s.upcase}']" }.join("\n  ")}
-        end
-      RUBY
-
-      raise ConfigurationError,
-            "#{@provider.name} provider is not configured. Add this to your initialization:\n\n#{config_block}"
-    end
-  end
-end

data/lib/ruby_llm/content.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  # Represents the content sent to or received from an LLM.
-  class Content
-    attr_reader :text, :attachments
-
-    def initialize(text = nil, attachments = nil)
-      @text = text
-      @attachments = []
-
-      process_attachments(attachments)
-      raise ArgumentError, 'Text and attachments cannot be both nil' if @text.nil? && @attachments.empty?
-    end
-
-    def add_attachment(source, filename: nil)
-      @attachments << build_attachment(source, filename:)
-      self
-    end
-
-    def format
-      if @text && @attachments.empty?
-        @text
-      else
-        self
-      end
-    end
-
-    def empty?
-      attachments.empty? && (@text.nil? || (@text.respond_to?(:empty?) && @text.empty?))
-    end
-
-    # For Rails serialization
-    def to_h
-      { text: @text, attachments: @attachments.map(&:to_h) }
-    end
-
-    private
-
-    def build_attachment(source, filename: nil)
-      if source.is_a?(Attachment)
-        return source unless filename
-
-        return Attachment.new(source.source, filename:)
-      end
-
-      Attachment.new(source, filename:)
-    end
-
-    def process_attachments_array_or_string(attachments)
-      Utils.to_safe_array(attachments).each do |file|
-        next if blank_attachment_entry?(file)
-
-        add_attachment(file)
-      end
-    end
-
-    def blank_attachment_entry?(file)
-      file.nil? || (file.is_a?(String) && file.strip.empty?)
-    end
-
-    def process_attachments(attachments)
-      if attachments.is_a?(Hash)
-        attachments.each_value { |attachment| process_attachments_array_or_string(attachment) }
-      else
-        process_attachments_array_or_string attachments
-      end
-    end
-  end
-
-  class Content
-    # Represents provider-specific payloads that should bypass RubyLLM formatting.
-    class Raw
-      attr_reader :value
-
-      def initialize(value)
-        raise ArgumentError, 'Raw content payload cannot be nil' if value.nil?
-
-        @value = value
-      end
-
-      def format
-        @value
-      end
-
-      def to_h
-        @value
-      end
-    end
-  end
-end

data/lib/ruby_llm/deprecator.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  # Owns RubyLLM deprecation warnings so applications and tests can decide how
-  # aggressively to handle compatibility paths.
-  class Deprecator
-    def warn(message)
-      case RubyLLM.config.deprecation_behavior
-      when :silence
-        nil
-      when :raise
-        raise DeprecationError, message
-      else
-        RubyLLM.logger.warn(message)
-      end
-    end
-
-    def deprecate(name, replacement:, removal:)
-      warn("#{name} is deprecated and will be removed in RubyLLM #{removal}. Use #{replacement} instead.")
-    end
-  end
-
-  class DeprecationError < StandardError; end
-end

data/lib/ruby_llm/error_middleware.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-require 'faraday'
-require 'ruby_llm/error'
-
-module RubyLLM
-  # Faraday middleware that maps provider-specific API errors to RubyLLM errors.
-  class ErrorMiddleware < Faraday::Middleware
-    def initialize(app, options = {})
-      super(app)
-      @provider = options[:provider]
-    end
-
-    def call(env)
-      @app.call(env).on_complete do |response|
-        self.class.parse_error(provider: @provider, response: response)
-      end
-    end
-
-    class << self
-      CONTEXT_LENGTH_PATTERNS = [
-        /context length/i,
-        /context window/i,
-        /maximum context/i,
-        /request too large/i,
-        /too many tokens/i,
-        /token count exceeds/i,
-        /input[_\s-]?token/i,
-        /input or output tokens? must be reduced/i,
-        /reduce the length of messages/i,
-        /prompt is too long/i
-      ].freeze
-
-      def parse_error(provider:, response:) # rubocop:disable Metrics/PerceivedComplexity
-        message = provider&.parse_error(response)
-
-        case response.status
-        when 200..399
-          message
-        when 400
-          if context_length_exceeded?(message)
-            raise ContextLengthExceededError.new(response, message || 'Context length exceeded')
-          end
-
-          raise BadRequestError.new(response, message || 'Invalid request - please check your input')
-        when 401
-          raise UnauthorizedError.new(response, message || 'Invalid API key - check your credentials')
-        when 402
-          raise PaymentRequiredError.new(response, message || 'Payment required - please top up your account')
-        when 403
-          raise ForbiddenError.new(response,
-                                   message || 'Forbidden - you do not have permission to access this resource')
-        when 429
-          if context_length_exceeded?(message)
-            raise ContextLengthExceededError.new(response, message || 'Context length exceeded')
-          end
-
-          raise RateLimitError.new(response, message || 'Rate limit exceeded - please wait a moment')
-        when 500
-          raise ServerError.new(response, message || 'API server error - please try again')
-        when 502..504
-          raise ServiceUnavailableError.new(response, message || 'API server unavailable - please try again later')
-        when 529
-          raise OverloadedError.new(response, message || 'Service overloaded - please try again later')
-        else
-          raise Error.new(response, message || 'An unknown error occurred')
-        end
-      end
-
-      private
-
-      def context_length_exceeded?(message)
-        return false if message.to_s.empty?
-
-        CONTEXT_LENGTH_PATTERNS.any? { |pattern| message.match?(pattern) }
-      end
-    end
-  end
-end
-
-Faraday::Middleware.register_middleware(llm_errors: RubyLLM::ErrorMiddleware)

data/lib/ruby_llm/instrumentation.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  # Emits structured RubyLLM events without requiring a specific observability
-  # backend. Rails apps can use ActiveSupport::Notifications as the instrumenter.
-  module Instrumentation
-    module_function
-
-    def instrument(name, payload = nil, config: nil, **attributes)
-      payload = build_payload(payload, attributes)
-      instrumenter = instrumenter_for(config)
-      return yield(payload) if block_given? && !instrumenter
-
-      unless instrumenter.respond_to?(:instrument)
-        return yield(payload) if block_given?
-
-        return
-      end
-
-      if block_given?
-        instrumenter.instrument(name, payload) { yield(payload) }
-      else
-        instrumenter.instrument(name, payload)
-      end
-    end
-
-    def build_payload(payload, attributes)
-      payload ||= {}
-      attributes.empty? ? payload : payload.merge(attributes)
-    end
-
-    def instrumenter_for(config)
-      (config || RubyLLM.config).instrumenter
-    end
-  end
-end

data/lib/ruby_llm/mime_type.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-require 'marcel'
-
-module RubyLLM
-  # MimeTypes module provides methods to handle MIME types using Marcel gem
-  module MimeType
-    module_function
-
-    def for(...)
-      Marcel::MimeType.for(...)
-    end
-
-    def image?(type)
-      type.start_with?('image/')
-    end
-
-    def video?(type)
-      type.start_with?('video/')
-    end
-
-    def audio?(type)
-      type.start_with?('audio/')
-    end
-
-    def pdf?(type)
-      type == 'application/pdf'
-    end
-
-    def document?(type)
-      return false if pdf?(type) || text?(type)
-
-      DOCUMENT_MIME_TYPES.include?(type) ||
-        DOCUMENT_MIME_PREFIXES.any? { |prefix| type.start_with?(prefix) }
-    end
-
-    def text?(type)
-      type.start_with?('text/') ||
-        TEXT_SUFFIXES.any? { |suffix| type.end_with?(suffix) } ||
-        NON_TEXT_PREFIX_TEXT_MIME_TYPES.include?(type)
-    end
-
-    # MIME types that have a text/ prefix but need to be handled differently
-    TEXT_SUFFIXES = ['+json', '+xml', '+html', '+yaml', '+csv', '+plain', '+javascript', '+svg'].freeze
-
-    # MIME types that don't have a text/ prefix but should be treated as text
-    NON_TEXT_PREFIX_TEXT_MIME_TYPES = [
-      'application/json', # Base type, even if specific ones end with +json
-      'application/xml',  # Base type, even if specific ones end with +xml
-      'application/javascript',
-      'application/ecmascript',
-      'application/rtf',
-      'application/sql',
-      'application/x-sh',
-      'application/x-csh',
-      'application/x-httpd-php',
-      'application/sdp',
-      'application/sparql-query',
-      'application/graphql',
-      'application/yang', # Data modeling language, often serialized as XML/JSON but the type itself is distinct
-      'application/mbox', # Mailbox format
-      'application/x-tex',
-      'application/x-latex',
-      'application/x-perl',
-      'application/x-python',
-      'application/x-tcl',
-      'application/pgp-signature', # Often ASCII armored
-      'application/pgp-keys',      # Often ASCII armored
-      'application/vnd.coffeescript',
-      'application/vnd.dart',
-      'application/vnd.oai.openapi', # Base for OpenAPI, often with +json or +yaml suffix
-      'application/vnd.zul',         # ZK User Interface Language (can be XML-like)
-      'application/x-yaml',          # Common non-standard for YAML
-      'application/yaml',            # Standard for YAML
-      'application/toml'             # TOML configuration files
-    ].freeze
-
-    DOCUMENT_MIME_TYPES = [
-      'application/msword',
-      'application/rtf',
-      'application/vnd.apple.keynote',
-      'application/vnd.apple.numbers',
-      'application/vnd.apple.pages',
-      'application/vnd.google-apps.document',
-      'application/vnd.google-apps.presentation',
-      'application/vnd.google-apps.spreadsheet',
-      'application/vnd.ms-excel',
-      'application/vnd.ms-powerpoint'
-    ].freeze
-
-    DOCUMENT_MIME_PREFIXES = [
-      'application/vnd.openxmlformats-officedocument.',
-      'application/vnd.oasis.opendocument.'
-    ].freeze
-  end
-end

data/lib/ruby_llm/model/info.rb

@@ -1,164 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module Model
-    # Information about an AI model's capabilities, pricing, and metadata.
-    class Info
-      attr_reader :id, :name, :provider, :family, :created_at, :context_window, :max_output_tokens, :knowledge_cutoff,
-                  :modalities, :capabilities, :pricing, :metadata, :reasoning_options
-
-      # Create a default model with assumed capabilities
-      def self.default(model_id, provider)
-        new(
-          id: model_id,
-          name: model_id.tr('-', ' ').capitalize,
-          provider: provider,
-          capabilities: %w[function_calling streaming vision structured_output],
-          modalities: { input: %w[text image], output: %w[text] },
-          metadata: { warning: 'Assuming model exists, capabilities may not be accurate' }
-        )
-      end
-
-      def initialize(data)
-        @id = data[:id]
-        @name = data[:name]
-        @provider = data[:provider]
-        @family = data[:family]
-        @created_at = Utils.to_time(data[:created_at])&.utc
-        @context_window = data[:context_window]
-        @max_output_tokens = data[:max_output_tokens]
-        @knowledge_cutoff = Utils.to_date(data[:knowledge_cutoff])
-        @modalities = Modalities.new(data[:modalities] || {})
-        @capabilities = data[:capabilities] || []
-        @pricing = Pricing.new(data[:pricing] || {})
-        @metadata = data[:metadata]&.dup || {}
-        @reasoning_options = normalize_reasoning_options(reasoning_options_from(data))
-        store_reasoning_options_metadata
-      end
-
-      def supports?(capability)
-        capabilities.include?(capability.to_s)
-      end
-
-      %w[function_calling structured_output batch reasoning citations streaming].each do |cap|
-        define_method "#{cap}?" do
-          supports?(cap)
-        end
-      end
-
-      def display_name
-        name
-      end
-
-      def label
-        provider_name = provider_class&.name || provider
-        "#{provider_name} - #{display_name}"
-      end
-
-      def max_tokens
-        max_output_tokens
-      end
-
-      def supports_vision?
-        modalities.input.include?('image')
-      end
-
-      def reasoning_option(type)
-        reasoning_options.find { |option| option[:type] == type.to_s }
-      end
-
-      def reasoning_option_values(type)
-        Array(reasoning_option(type)&.fetch(:values, nil))
-      end
-
-      def supports_video?
-        modalities.input.include?('video')
-      end
-
-      def supports_functions?
-        function_calling?
-      end
-
-      def input_price_per_million
-        pricing.text_tokens.input
-      end
-
-      def output_price_per_million
-        pricing.text_tokens.output
-      end
-
-      def cache_read_input_price_per_million
-        pricing.text_tokens.cache_read_input
-      end
-
-      def cache_write_input_price_per_million
-        pricing.text_tokens.cache_write_input
-      end
-
-      alias cached_input_price_per_million cache_read_input_price_per_million
-      alias cache_creation_input_price_per_million cache_write_input_price_per_million
-
-      def cost_for(tokens)
-        tokens = tokens.tokens if tokens.respond_to?(:tokens)
-
-        Cost.new(tokens:, model: self)
-      end
-
-      def provider_class
-        RubyLLM::Provider.resolve provider
-      end
-
-      def type
-        output = modalities.output
-        return 'embedding' if output.include?('embeddings')
-        return 'moderation' if output.include?('moderation')
-        return 'image' if output.include?('image')
-        return 'audio' if output.include?('audio')
-        return 'video' if output.include?('video')
-
-        'chat'
-      end
-
-      def to_h
-        {
-          id: id,
-          name: name,
-          provider: provider,
-          family: family,
-          created_at: created_at,
-          context_window: context_window,
-          max_output_tokens: max_output_tokens,
-          knowledge_cutoff: knowledge_cutoff,
-          modalities: modalities.to_h,
-          capabilities: capabilities,
-          pricing: pricing.to_h,
-          metadata: metadata
-        }
-      end
-
-      private
-
-      def reasoning_options_from(data)
-        data[:reasoning_options] || metadata[:reasoning_options] || metadata['reasoning_options']
-      end
-
-      def store_reasoning_options_metadata
-        return unless reasoning_options.any?
-
-        metadata.delete('reasoning_options')
-        metadata[:reasoning_options] = reasoning_options
-      end
-
-      def normalize_reasoning_options(options)
-        Array(options).filter_map do |option|
-          next unless option.is_a?(Hash)
-
-          normalized = option.to_h.transform_keys(&:to_sym)
-          normalized[:type] = normalized[:type].to_s if normalized[:type]
-          normalized[:values] = Array(normalized[:values]).map(&:to_s) if normalized.key?(:values)
-          normalized
-        end
-      end
-    end
-  end
-end