ruby_llm 1.15.0 → 2.0.0.rc1

data/lib/ruby_llm/connection.rb

@@ -1,130 +0,0 @@
-# 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,
-                   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, &)
-      @connection.post url, payload do |req|
-        req.headers.merge! @provider.headers 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 if @provider.respond_to?(:headers)
-        yield req if block_given?
-      end
-    end
-
-    def instance_variables
-      super - %i[@config @connection]
-    end
-
-    private
-
-    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
-      faraday.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,77 +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 << Attachment.new(source, filename:)
-      self
-    end
-
-    def format
-      if @text && @attachments.empty?
-        @text
-      else
-        self
-      end
-    end
-
-    # For Rails serialization
-    def to_h
-      { text: @text, attachments: @attachments.map(&:to_h) }
-    end
-
-    private
-
-    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/mime_type.rb

@@ -1,71 +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 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
-  end
-end

data/lib/ruby_llm/model/info.rb

@@ -1,130 +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
-
-      # 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] || {}
-      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 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
-    end
-  end
-end

data/lib/ruby_llm/models_schema.json

@@ -1,171 +0,0 @@
-{
-  "title": "RubyLLM Models Schema",
-  "description": "Schema for validating the structure of models.json",
-  "type": "array",
-  "items": {
-    "type": "object",
-    "required": ["id", "name", "provider", "context_window", "max_output_tokens"],
-    "properties": {
-      "id": {
-        "type": "string",
-        "description": "Unique identifier for the model"
-      },
-      "name": {
-        "type": "string",
-        "description": "Display name of the model"
-      },
-      "provider": {
-        "type": "string",
-        "description": "Provider of the model (e.g., openai, anthropic, mistral)"
-      },
-      "family": {
-        "type": ["string", "null"],
-        "description": "Model family (e.g., gpt-4, claude-3)"
-      },
-      "created_at": {
-        "type": ["null", {"type": "string", "format": "date-time"}],
-        "description": "Creation date of the model"
-      },
-      "context_window": {
-        "type": ["null", {"type": "integer", "minimum": 0}],
-        "description": "Maximum context window size"
-      },
-      "max_output_tokens": {
-        "type": ["null", {"type": "integer", "minimum": 0}],
-        "description": "Maximum output tokens"
-      },
-      "knowledge_cutoff": {
-        "type": ["null", {"type": "string", "format": "date"}],
-        "description": "Knowledge cutoff date"
-      },
-      "modalities": {
-        "type": "object",
-        "required": ["input", "output"],
-        "properties": {
-          "input": {
-            "type": "array",
-            "items": {
-              "type": "string",
-              "enum": ["text", "image", "audio", "pdf", "video", "file"]
-            },
-            "uniqueItems": true,
-            "description": "Supported input modalities"
-          },
-          "output": {
-            "type": "array",
-            "items": {
-              "type": "string",
-              "enum": ["text", "image", "audio", "video", "embeddings", "moderation"]
-            },
-            "uniqueItems": true,
-            "description": "Supported output modalities"
-          }
-        }
-      },
-      "capabilities": {
-        "type": "array",
-        "items": {
-          "type": "string",
-          "enum": [
-            "streaming", "function_calling", "structured_output", "predicted_outputs",
-            "distillation", "fine_tuning", "batch", "realtime", "image_generation",
-            "speech_generation", "transcription", "translation", "citations", "reasoning",
-            "caching", "moderation", "json_mode", "vision"
-          ]
-        },
-        "uniqueItems": true,
-        "description": "Model capabilities"
-      },
-      "pricing": {
-        "type": "object",
-        "properties": {
-          "text_tokens": {
-            "type": "object",
-            "required": ["standard"],
-            "properties": {
-              "standard": {
-                "type": "object",
-                "properties": {
-                  "input_per_million": {"type": "number", "minimum": 0},
-                  "cache_read_input_per_million": {"type": "number", "minimum": 0},
-                  "cache_write_input_per_million": {"type": "number", "minimum": 0},
-                  "cached_input_per_million": {"type": "number", "minimum": 0},
-                  "cache_creation_input_per_million": {"type": "number", "minimum": 0},
-                  "output_per_million": {"type": "number", "minimum": 0},
-                  "reasoning_output_per_million": {"type": "number", "minimum": 0}
-                }
-              },
-              "batch": {
-                "type": "object",
-                "properties": {
-                  "input_per_million": {"type": "number", "minimum": 0},
-                  "output_per_million": {"type": "number", "minimum": 0}
-                }
-              }
-            }
-          },
-          "images": {
-            "type": "object",
-            "properties": {
-              "standard": {
-                "type": "object",
-                "properties": {
-                  "input": {"type": "number", "minimum": 0},
-                  "output": {"type": "number", "minimum": 0}
-                }
-              },
-              "batch": {
-                "type": "object",
-                "properties": {
-                  "input": {"type": "number", "minimum": 0},
-                  "output": {"type": "number", "minimum": 0}
-                }
-              }
-            }
-          },
-          "audio_tokens": {
-            "type": "object",
-            "properties": {
-              "standard": {
-                "type": "object",
-                "properties": {
-                  "input_per_million": {"type": "number", "minimum": 0},
-                  "output_per_million": {"type": "number", "minimum": 0}
-                }
-              },
-              "batch": {
-                "type": "object",
-                "properties": {
-                  "input_per_million": {"type": "number", "minimum": 0},
-                  "output_per_million": {"type": "number", "minimum": 0}
-                }
-              }
-            }
-          },
-          "embeddings": {
-            "type": "object",
-            "properties": {
-              "standard": {
-                "type": "object",
-                "properties": {
-                  "input_per_million": {"type": "number", "minimum": 0}
-                }
-              },
-              "batch": {
-                "type": "object",
-                "properties": {
-                  "input_per_million": {"type": "number", "minimum": 0}
-                }
-              }
-            }
-          }
-        },
-        "description": "Pricing information for the model"
-      },
-      "metadata": {
-        "type": "object",
-        "description": "Additional metadata about the model"
-      }
-    }
-  }
-}