ruby_llm_community 0.0.1 → 0.0.3

data/lib/ruby_llm/models.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  # Registry of available AI models and their capabilities. Provides a clean interface
+  # to discover and work with models from different providers.
+  #
+  # Example:
+  #   RubyLLM.models.all                                  # All available models
+  #   RubyLLM.models.chat_models                          # Models that support chat
+  #   RubyLLM.models.by_provider('openai').chat_models    # OpenAI chat models
+  #   RubyLLM.models.find('claude-3')                     # Get info about a specific model
+  class Models
+    include Enumerable
+
+    class << self
+      def instance
+        @instance ||= new
+      end
+
+      def provider_for(model)
+        Provider.for(model)
+      end
+
+      def models_file
+        File.expand_path('models.json', __dir__)
+      end
+
+      def refresh!
+        # Collect models from both sources
+        provider_models = fetch_from_providers
+        parsera_models = fetch_from_parsera
+
+        # Merge with parsera data taking precedence
+        merged_models = merge_models(provider_models, parsera_models)
+
+        @instance = new(merged_models)
+      end
+
+      def fetch_from_providers
+        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(&:name).join(', ')}"
+
+        configured.flat_map(&:list_models)
+      end
+
+      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_class ||= raise(Error, "Unknown provider: #{provider.to_sym}")
+          provider_instance = provider_class.new(config)
+
+          model = Model::Info.new(
+            id: model_id,
+            name: model_id.tr('-', ' ').capitalize,
+            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' }
+          )
+        else
+          model = Models.find model_id, provider
+          provider_class = Provider.providers[model.provider.to_sym] || raise(Error,
+                                                                              "Unknown provider: #{model.provider}")
+          provider_instance = provider_class.new(config)
+        end
+        [model, provider_instance]
+      end
+
+      def method_missing(method, ...)
+        if instance.respond_to?(method)
+          instance.send(method, ...)
+        else
+          super
+        end
+      end
+
+      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 = Connection.basic do |f|
+          f.request :json
+          f.response :json, parser_options: { symbolize_names: true }
+        end
+        response = connection.get 'https://api.parsera.org/v1/llm-specs'
+        models = response.body.map { |data| Model::Info.new(data) }
+        models.reject { |model| model.provider.nil? || model.id.nil? }
+      end
+
+      def merge_models(provider_models, parsera_models)
+        parsera_by_key = index_by_key(parsera_models)
+        provider_by_key = index_by_key(provider_models)
+
+        all_keys = parsera_by_key.keys | provider_by_key.keys
+
+        models = all_keys.map do |key|
+          if (parsera_model = parsera_by_key[key])
+            if (provider_model = provider_by_key[key])
+              add_provider_metadata(parsera_model, provider_model)
+            else
+              parsera_model
+            end
+          else
+            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)
+        data = parsera_model.to_h
+        data[:metadata] = provider_model.metadata.merge(data[:metadata] || {})
+        Model::Info.new(data)
+      end
+    end
+
+    def initialize(models = nil)
+      @models = models || load_models
+    end
+
+    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) }
+    rescue JSON::ParserError
+      []
+    end
+
+    def save_models
+      File.write(self.class.models_file, JSON.pretty_generate(all.map(&:to_h)))
+    end
+
+    def all
+      @models
+    end
+
+    def each(&)
+      all.each(&)
+    end
+
+    def find(model_id, provider = nil)
+      if provider
+        find_with_provider(model_id, provider)
+      else
+        find_without_provider(model_id)
+      end
+    end
+
+    def chat_models
+      self.class.new(all.select { |m| m.type == 'chat' })
+    end
+
+    def embedding_models
+      self.class.new(all.select { |m| m.type == 'embedding' })
+    end
+
+    def audio_models
+      self.class.new(all.select { |m| m.type == 'audio' })
+    end
+
+    def image_models
+      self.class.new(all.select { |m| m.type == 'image' })
+    end
+
+    def by_family(family)
+      self.class.new(all.select { |m| m.family == family.to_s })
+    end
+
+    def by_provider(provider)
+      self.class.new(all.select { |m| m.provider == provider.to_s })
+    end
+
+    def refresh!
+      self.class.refresh!
+    end
+
+    private
+
+    def find_with_provider(model_id, provider)
+      resolved_id = Aliases.resolve(model_id, provider)
+      all.find { |m| m.id == model_id && m.provider == provider.to_s } ||
+        all.find { |m| m.id == resolved_id && m.provider == provider.to_s } ||
+        raise(ModelNotFoundError, "Unknown model: #{model_id} for provider: #{provider}")
+    end
+
+    def find_without_provider(model_id)
+      all.find { |m| m.id == model_id } ||
+        all.find { |m| m.id == Aliases.resolve(model_id) } ||
+        raise(ModelNotFoundError, "Unknown model: #{model_id}")
+    end
+  end
+end

data/lib/ruby_llm/models_schema.json

@@ -0,0 +1,168 @@
+{
+  "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", "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},
+                  "cached_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"
+      }
+    }
+  }
+}

data/lib/ruby_llm/provider.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  # 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.
+  # Encapsulates configuration and connection to eliminate parameter threading.
+  class Provider
+    include Streaming
+
+    attr_reader :config, :connection
+
+    def initialize(config)
+      @config = config
+      ensure_configured!
+      @connection = Connection.new(self, @config)
+    end
+
+    def api_base
+      raise NotImplementedError
+    end
+
+    def headers
+      {}
+    end
+
+    def slug
+      self.class.slug
+    end
+
+    def name
+      self.class.name
+    end
+
+    def capabilities
+      self.class.capabilities
+    end
+
+    def configuration_requirements
+      self.class.configuration_requirements
+    end
+
+    def complete(messages, tools:, temperature:, model:, params: {}, headers: {}, schema: nil, # rubocop:disable Metrics/ParameterLists
+                 cache_prompts: { system: false, user: false, tools: false }, &)
+      normalized_temperature = maybe_normalize_temperature(temperature, model)
+
+      payload = Utils.deep_merge(
+        params,
+        render_payload(
+          messages,
+          tools: tools,
+          temperature: normalized_temperature,
+          model: model,
+          cache_prompts: cache_prompts,
+          stream: block_given?,
+          schema: schema
+        )
+      )
+
+      if block_given?
+        stream_response @connection, payload, headers, &
+      else
+        sync_response @connection, payload, headers
+      end
+    end
+
+    def list_models
+      response = @connection.get models_url
+      parse_list_models_response response, slug, capabilities
+    end
+
+    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
+
+    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)
+      return if response.body.empty?
+
+      body = try_parse_json(response.body)
+      case body
+      when Hash
+        body.dig('error', 'message')
+      when Array
+        body.map do |part|
+          part.dig('error', 'message')
+        end.join('. ')
+      else
+        body
+      end
+    end
+
+    def format_messages(messages)
+      messages.map do |msg|
+        {
+          role: msg.role.to_s,
+          content: msg.content
+        }
+      end
+    end
+
+    def format_tool_calls(_tool_calls)
+      nil
+    end
+
+    def parse_tool_calls(_tool_calls)
+      nil
+    end
+
+    class << self
+      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 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)
+        model_info = Models.find(model)
+        providers[model_info.provider.to_sym]
+      end
+
+      def providers
+        @providers ||= {}
+      end
+
+      def local_providers
+        providers.select { |_slug, provider_class| provider_class.local? }
+      end
+
+      def remote_providers
+        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 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