ruby_llm_swarm 1.9.1

data/lib/ruby_llm/models.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  # Registry of available AI models and their capabilities.
+  class Models
+    include Enumerable
+
+    class << self
+      def instance
+        @instance ||= new
+      end
+
+      def schema_file
+        File.expand_path('models_schema.json', __dir__)
+      end
+
+      def load_models(file = RubyLLM.config.model_registry_file)
+        read_from_json(file)
+      end
+
+      def read_from_json(file = RubyLLM.config.model_registry_file)
+        data = File.exist?(file) ? File.read(file) : '[]'
+        JSON.parse(data, symbolize_names: true).map { |model| Model::Info.new(model) }
+      rescue JSON::ParserError
+        []
+      end
+
+      def refresh!(remote_only: false)
+        provider_models = fetch_from_providers(remote_only: remote_only)
+        parsera_models = fetch_from_parsera
+        merged_models = merge_models(provider_models, parsera_models)
+        @instance = new(merged_models)
+      end
+
+      def fetch_from_providers(remote_only: true)
+        config = RubyLLM.config
+        configured_classes = if remote_only
+                               Provider.configured_remote_providers(config)
+                             else
+                               Provider.configured_providers(config)
+                             end
+        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
+
+        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 = if provider_instance.local?
+                    begin
+                      Models.find(model_id, provider)
+                    rescue ModelNotFoundError
+                      nil
+                    end
+                  end
+
+          model ||= Model::Info.default(model_id, provider_instance.slug)
+        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|
+          parsera_model = find_parsera_model(key, parsera_by_key)
+          provider_model = provider_by_key[key]
+
+          if parsera_model && provider_model
+            add_provider_metadata(parsera_model, provider_model)
+          elsif parsera_model
+            parsera_model
+          else
+            provider_model
+          end
+        end
+
+        models.sort_by { |m| [m.provider, m.id] }
+      end
+
+      def find_parsera_model(key, parsera_by_key)
+        # Direct match
+        return parsera_by_key[key] if parsera_by_key[key]
+
+        # VertexAI uses same models as Gemini
+        provider, model_id = key.split(':', 2)
+        return unless provider == 'vertexai'
+
+        gemini_model = parsera_by_key["gemini:#{model_id}"]
+        return unless gemini_model
+
+        # Return Gemini's Parsera data but with VertexAI as provider
+        Model::Info.new(gemini_model.to_h.merge(provider: 'vertexai'))
+      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 || self.class.load_models
+    end
+
+    def load_from_json!(file = RubyLLM.config.model_registry_file)
+      @models = self.class.read_from_json(file)
+    end
+
+    def save_to_json(file = RubyLLM.config.model_registry_file)
+      File.write(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' || m.modalities.output.include?('embeddings') })
+    end
+
+    def audio_models
+      self.class.new(all.select { |m| m.type == 'audio' || m.modalities.output.include?('audio') })
+    end
+
+    def image_models
+      self.class.new(all.select { |m| m.type == 'image' || m.modalities.output.include?('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!(remote_only: false)
+      self.class.refresh!(remote_only: remote_only)
+    end
+
+    def resolve(model_id, provider: nil, assume_exists: false, config: nil)
+      self.class.resolve(model_id, provider: provider, assume_exists: assume_exists, config: config)
+    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/moderation.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  # Identify potentially harmful content in text.
+  # https://platform.openai.com/docs/guides/moderation
+  class Moderation
+    attr_reader :id, :model, :results
+
+    def initialize(id:, model:, results:)
+      @id = id
+      @model = model
+      @results = results
+    end
+
+    def self.moderate(input,
+                      model: nil,
+                      provider: nil,
+                      assume_model_exists: false,
+                      context: nil)
+      config = context&.config || RubyLLM.config
+      model ||= config.default_moderation_model || 'omni-moderation-latest'
+      model, provider_instance = Models.resolve(model, provider: provider, assume_exists: assume_model_exists,
+                                                       config: config)
+      model_id = model.id
+
+      provider_instance.moderate(input, model: model_id)
+    end
+
+    # Convenience method to get content from moderation result
+    def content
+      results
+    end
+
+    # Check if any content was flagged
+    def flagged?
+      results.any? { |result| result['flagged'] }
+    end
+
+    # Get all flagged categories across all results
+    def flagged_categories
+      results.flat_map do |result|
+        result['categories']&.select { |_category, flagged| flagged }&.keys || []
+      end.uniq
+    end
+
+    # Get category scores for the first result (most common case)
+    def category_scores
+      results.first&.dig('category_scores') || {}
+    end
+
+    # Get categories for the first result (most common case)
+    def categories
+      results.first&.dig('categories') || {}
+    end
+  end
+end

data/lib/ruby_llm/provider.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  # Base class for LLM providers.
+  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
+      normalized_temperature = maybe_normalize_temperature(temperature, model)
+
+      payload = Utils.deep_merge(
+        render_payload(
+          messages,
+          tools: tools,
+          temperature: normalized_temperature,
+          model: model,
+          stream: block_given?,
+          schema: schema
+        ),
+        params
+      )
+
+      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 moderate(input, model:)
+      payload = render_moderation_payload(input, model:)
+      response = @connection.post moderation_url, payload
+      parse_moderation_response(response, model:)
+    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 transcribe(audio_file, model:, language:, **options)
+      file_part = build_audio_file_part(audio_file)
+      payload = render_transcription_payload(file_part, model:, language:, **options)
+      response = @connection.post transcription_url, payload
+      parse_transcription_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 resolve(name)
+        providers[name.to_sym]
+      end
+
+      def for(model)
+        model_info = Models.find(model)
+        resolve model_info.provider
+      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 build_audio_file_part(file_path)
+      expanded_path = File.expand_path(file_path)
+      mime_type = Marcel::MimeType.for(Pathname.new(expanded_path))
+
+      Faraday::Multipart::FilePart.new(
+        expanded_path,
+        mime_type,
+        File.basename(expanded_path)
+      )
+    end
+
+    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)
+      temperature
+    end
+
+    def sync_response(connection, payload, additional_headers = {})
+      response = connection.post completion_url, payload do |req|
+        req.headers = additional_headers.merge(req.headers) unless additional_headers.empty?
+      end
+      parse_completion_response response
+    end
+  end
+end