vibe-sort 0.2.0 → 0.3.1

data/lib/vibe_sort/configuration.rb

@@ -2,20 +2,29 @@
 
 module VibeSort
   # Configuration class for VibeSort
-  # Holds API key and temperature settings
+  # Holds provider, API key, model, and temperature settings
   class Configuration
-    attr_reader :api_key, :temperature
+    PROVIDERS = %i[openai anthropic gemini groq spacexai].freeze
+
+    attr_reader :api_key, :temperature, :provider, :model
 
     # Initialize a new Configuration
     #
-    # @param api_key [String] OpenAI API key
-    # @param temperature [Float] Temperature for the model (0.0 to 2.0)
-    # @raise [ArgumentError] if api_key is nil or empty
-    def initialize(api_key:, temperature: 0.0)
+    # @param api_key [String] API key for the selected provider
+    # @param temperature [Float] Temperature for the model (0.0 to 2.0).
+    #   Ignored by providers whose current models do not accept it (Anthropic).
+    # @param provider [Symbol, String] LLM provider: :openai (default), :anthropic, :gemini, :groq, or :spacexai
+    # @param model [String, nil] Model ID override (nil uses the provider's default)
+    # @raise [ArgumentError] if api_key is nil or empty, or provider is unknown
+    def initialize(api_key:, temperature: 0.0, provider: :openai, model: nil)
       raise ArgumentError, "API key cannot be nil or empty" if api_key.nil? || api_key.empty?
 
+      @provider = provider.to_s.to_sym
+      raise ArgumentError, "Unknown provider: #{provider.inspect} (supported: #{PROVIDERS.join(", ")})" unless PROVIDERS.include?(@provider)
+
       @api_key = api_key
       @temperature = temperature
+      @model = model
     end
   end
 end

data/lib/vibe_sort/providers/anthropic.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module VibeSort
+  module Providers
+    # Adapter for the Anthropic Messages API
+    #
+    # Uses structured outputs (output_config.format with a JSON schema) so the
+    # model is guaranteed to return the { "sorted_array": [...] } shape.
+    #
+    # Note: current Claude models (Opus 4.7+) reject the temperature parameter,
+    # so config.temperature is not forwarded to this provider.
+    class Anthropic < Base
+      ENDPOINT = "https://api.anthropic.com/v1/messages"
+      DEFAULT_MODEL = "claude-opus-4-8"
+      API_VERSION = "2023-06-01"
+      MAX_TOKENS = 4096
+
+      OUTPUT_SCHEMA = {
+        type: "object",
+        properties: {
+          sorted_array: {
+            type: "array",
+            items: { anyOf: [{ type: "number" }, { type: "string" }] }
+          }
+        },
+        required: ["sorted_array"],
+        additionalProperties: false
+      }.freeze
+
+      private
+
+      def provider_name
+        "Anthropic"
+      end
+
+      def endpoint
+        ENDPOINT
+      end
+
+      def headers
+        {
+          "x-api-key" => config.api_key,
+          "anthropic-version" => API_VERSION
+        }
+      end
+
+      def build_payload(array)
+        {
+          model: model,
+          max_tokens: MAX_TOKENS,
+          system: SYSTEM_PROMPT,
+          output_config: { format: { type: "json_schema", schema: OUTPUT_SCHEMA } },
+          messages: [
+            { role: "user", content: user_prompt(array) }
+          ]
+        }
+      end
+
+      def extract_content(response)
+        blocks = response.body["content"]
+        return nil unless blocks.is_a?(Array)
+
+        text_block = blocks.find { |block| block.is_a?(Hash) && block["type"] == "text" }
+        text_block && text_block["text"]
+      end
+    end
+  end
+end

data/lib/vibe_sort/providers/base.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module VibeSort
+  module Providers
+    # Base class for LLM provider adapters.
+    #
+    # Holds everything that is provider-agnostic: the sorting prompt, the
+    # Faraday connection plumbing, and validation of the returned array.
+    # Subclasses implement the provider-specific hooks: +provider_name+,
+    # +endpoint+, +headers+, +build_payload+, and +extract_content+.
+    class Base
+      SYSTEM_PROMPT = "You are an assistant that only sorts arrays. The array may contain numbers and strings. Sort the array in ascending order. Follow standard sorting rules: numbers should come before strings, and string sorting should be case-sensitive. Return a JSON object with a single key 'sorted_array' containing the sorted elements."
+
+      attr_reader :config
+
+      # @param config [VibeSort::Configuration] Configuration object
+      def initialize(config)
+        @config = config
+      end
+
+      # Perform the sorting operation via the provider's API
+      #
+      # @param array [Array] Array of numbers and/or strings to sort
+      # @return [Hash] Result hash with :success and :sorted_array keys
+      # @raise [VibeSort::ApiError] if the API request fails
+      def perform(array)
+        response = connection.post do |req|
+          req.body = build_payload(array)
+        end
+
+        handle_response(response)
+      end
+
+      private
+
+      # Model to use: explicit override from config, or the provider default
+      #
+      # @return [String] Model ID
+      def model
+        config.model || self.class::DEFAULT_MODEL
+      end
+
+      # @param array [Array] Array to sort
+      # @return [String] User prompt sent to the model
+      def user_prompt(array)
+        "Please sort this array: #{array.to_json}"
+      end
+
+      # @return [Faraday::Connection] Faraday connection object
+      def connection
+        @connection ||= Faraday.new(url: endpoint) do |f|
+          f.request :json  # Encodes request body as JSON
+          f.response :json # Decodes response body as JSON
+          headers.each { |name, value| f.headers[name] = value }
+          f.headers["Content-Type"] = "application/json"
+          f.adapter Faraday.default_adapter
+        end
+      end
+
+      # @param response [Faraday::Response] HTTP response
+      # @return [Hash] Result hash
+      # @raise [VibeSort::ApiError] if response is invalid or parsing fails
+      def handle_response(response)
+        unless response.success?
+          error_message = extract_error_message(response)
+          raise ApiError.new("#{provider_name} API error: #{error_message}", response)
+        end
+
+        parse_sorted_array(response)
+      end
+
+      # Extract error message from failed response. Works for all three
+      # providers: OpenAI, Anthropic, and Gemini all return an "error"
+      # object with a "message" key on failure.
+      #
+      # @param response [Faraday::Response] HTTP response
+      # @return [String] Error message
+      def extract_error_message(response)
+        return "Unknown error" unless response.body.is_a?(Hash)
+
+        response.body.dig("error", "message") || "HTTP #{response.status}"
+      rescue StandardError
+        "HTTP #{response.status}"
+      end
+
+      # Parse the sorted array from the API response
+      #
+      # @param response [Faraday::Response] HTTP response
+      # @return [Hash] Success result with sorted array
+      # @raise [VibeSort::ApiError] if parsing fails or validation fails
+      def parse_sorted_array(response)
+        content = extract_content(response)
+        raise ApiError.new("Invalid response structure", response) if content.nil?
+
+        parsed_content = JSON.parse(content)
+        sorted_array = parsed_content["sorted_array"]
+
+        validate_sorted_array!(sorted_array)
+
+        { success: true, sorted_array: sorted_array }
+      rescue JSON::ParserError => e
+        raise ApiError.new("Failed to parse JSON response: #{e.message}", response)
+      end
+
+      # Validate that the sorted array is valid
+      #
+      # @param sorted_array [Object] Parsed sorted array
+      # @raise [VibeSort::ApiError] if validation fails
+      def validate_sorted_array!(sorted_array)
+        raise ApiError, "Response does not contain a valid 'sorted_array'" unless sorted_array.is_a?(Array)
+
+        return if sorted_array.all? { |item| item.is_a?(Numeric) || item.is_a?(String) }
+
+        raise ApiError, "Sorted array contains invalid values (must be numbers or strings)"
+      end
+
+      # --- Provider-specific hooks ---
+
+      # @return [String] Human-readable provider name used in error messages
+      def provider_name
+        raise NotImplementedError
+      end
+
+      # @return [String] Full URL of the API endpoint
+      def endpoint
+        raise NotImplementedError
+      end
+
+      # @return [Hash] Provider-specific HTTP headers (auth etc.)
+      def headers
+        raise NotImplementedError
+      end
+
+      # @param array [Array] Array to sort
+      # @return [Hash] Provider-specific request payload
+      def build_payload(array)
+        raise NotImplementedError
+      end
+
+      # @param response [Faraday::Response] HTTP response
+      # @return [String, nil] Raw JSON text produced by the model
+      def extract_content(response)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/vibe_sort/providers/gemini.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module VibeSort
+  module Providers
+    # Adapter for the Google Gemini API (generateContent)
+    class Gemini < Base
+      BASE_URL = "https://generativelanguage.googleapis.com/v1beta/models"
+      DEFAULT_MODEL = "gemini-2.5-flash"
+
+      private
+
+      def provider_name
+        "Gemini"
+      end
+
+      # The Gemini endpoint embeds the model ID in the URL path
+      def endpoint
+        "#{BASE_URL}/#{model}:generateContent"
+      end
+
+      def headers
+        { "x-goog-api-key" => config.api_key }
+      end
+
+      def build_payload(array)
+        {
+          systemInstruction: { parts: [{ text: SYSTEM_PROMPT }] },
+          contents: [
+            { role: "user", parts: [{ text: user_prompt(array) }] }
+          ],
+          generationConfig: {
+            temperature: config.temperature,
+            responseMimeType: "application/json"
+          }
+        }
+      end
+
+      def extract_content(response)
+        response.body.dig("candidates", 0, "content", "parts", 0, "text")
+      end
+    end
+  end
+end

data/lib/vibe_sort/providers/groq.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module VibeSort
+  module Providers
+    # Adapter for the Groq API (OpenAI-compatible Chat Completions)
+    class Groq < OpenAI
+      ENDPOINT = "https://api.groq.com/openai/v1/chat/completions"
+      DEFAULT_MODEL = "llama-3.3-70b-versatile"
+
+      private
+
+      def provider_name
+        "Groq"
+      end
+
+      def endpoint
+        ENDPOINT
+      end
+    end
+  end
+end

data/lib/vibe_sort/providers/openai.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module VibeSort
+  module Providers
+    # Adapter for the OpenAI Chat Completions API
+    class OpenAI < Base
+      ENDPOINT = "https://api.openai.com/v1/chat/completions"
+      DEFAULT_MODEL = "gpt-4o-mini"
+
+      private
+
+      def provider_name
+        "OpenAI"
+      end
+
+      def endpoint
+        ENDPOINT
+      end
+
+      def headers
+        { "Authorization" => "Bearer #{config.api_key}" }
+      end
+
+      def build_payload(array)
+        {
+          model: model,
+          temperature: config.temperature,
+          response_format: { type: "json_object" },
+          messages: [
+            { role: "system", content: SYSTEM_PROMPT },
+            { role: "user", content: user_prompt(array) }
+          ]
+        }
+      end
+
+      def extract_content(response)
+        response.body.dig("choices", 0, "message", "content")
+      end
+    end
+  end
+end

data/lib/vibe_sort/providers/space_x_ai.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module VibeSort
+  module Providers
+    # Adapter for the SpaceXAI (xAI) Grok API (OpenAI-compatible Chat Completions)
+    class SpaceXAI < OpenAI
+      ENDPOINT = "https://api.x.ai/v1/chat/completions"
+      DEFAULT_MODEL = "grok-4"
+
+      private
+
+      def provider_name
+        "SpaceXAI"
+      end
+
+      def endpoint
+        ENDPOINT
+      end
+    end
+  end
+end

data/lib/vibe_sort/sorter.rb

@@ -1,10 +1,15 @@
 # frozen_string_literal: true
 
 module VibeSort
-  # Sorter class handles the API call to OpenAI
+  # Sorter dispatches the sorting operation to the configured provider adapter
   class Sorter
-    OPENAI_API_URL = "https://api.openai.com/v1/chat/completions"
-    DEFAULT_MODEL = "gpt-3.5-turbo-1106"
+    PROVIDER_CLASSES = {
+      openai: Providers::OpenAI,
+      anthropic: Providers::Anthropic,
+      gemini: Providers::Gemini,
+      groq: Providers::Groq,
+      spacexai: Providers::SpaceXAI
+    }.freeze
 
     attr_reader :config
 
@@ -15,111 +20,13 @@ module VibeSort
       @config = config
     end
 
-    # Perform the sorting operation via OpenAI API
+    # Perform the sorting operation via the configured provider's API
     #
     # @param array [Array] Array of numbers and/or strings to sort
     # @return [Hash] Result hash with :success, :sorted_array, and optional :error keys
     # @raise [VibeSort::ApiError] if the API request fails
     def perform(array)
-      response = connection.post do |req|
-        req.body = build_payload(array)
-      end
-
-      handle_response(response)
-    end
-
-    private
-
-    # Build the connection to OpenAI API
-    #
-    # @return [Faraday::Connection] Faraday connection object
-    def connection
-      @connection ||= Faraday.new(url: OPENAI_API_URL) do |f|
-        f.request :json  # Encodes request body as JSON
-        f.response :json # Decodes response body as JSON
-        f.headers["Authorization"] = "Bearer #{config.api_key}"
-        f.headers["Content-Type"] = "application/json"
-        f.adapter Faraday.default_adapter
-      end
-    end
-
-    # Build the request payload for OpenAI API
-    #
-    # @param array [Array] Array to sort (numbers and/or strings)
-    # @return [Hash] Request payload
-    def build_payload(array)
-      {
-        model: DEFAULT_MODEL,
-        temperature: config.temperature,
-        response_format: { type: "json_object" },
-        messages: [
-          {
-            role: "system",
-            content: "You are an assistant that only sorts arrays. The array may contain numbers and strings. Sort the array in ascending order. Follow standard sorting rules: numbers should come before strings, and string sorting should be case-sensitive. Return a JSON object with a single key 'sorted_array' containing the sorted elements."
-          },
-          {
-            role: "user",
-            content: "Please sort this array: #{array.to_json}"
-          }
-        ]
-      }
-    end
-
-    # Handle the API response
-    #
-    # @param response [Faraday::Response] HTTP response
-    # @return [Hash] Result hash
-    # @raise [VibeSort::ApiError] if response is invalid or parsing fails
-    def handle_response(response)
-      unless response.success?
-        error_message = extract_error_message(response)
-        raise ApiError.new("OpenAI API error: #{error_message}", response)
-      end
-
-      parse_sorted_array(response)
-    end
-
-    # Extract error message from failed response
-    #
-    # @param response [Faraday::Response] HTTP response
-    # @return [String] Error message
-    def extract_error_message(response)
-      return "Unknown error" unless response.body.is_a?(Hash)
-
-      response.body.dig("error", "message") || "HTTP #{response.status}"
-    rescue StandardError
-      "HTTP #{response.status}"
-    end
-
-    # Parse the sorted array from the API response
-    #
-    # @param response [Faraday::Response] HTTP response
-    # @return [Hash] Success result with sorted array
-    # @raise [VibeSort::ApiError] if parsing fails or validation fails
-    def parse_sorted_array(response)
-      content = response.body.dig("choices", 0, "message", "content")
-      raise ApiError.new("Invalid response structure", response) if content.nil?
-
-      parsed_content = JSON.parse(content)
-      sorted_array = parsed_content["sorted_array"]
-
-      validate_sorted_array!(sorted_array)
-
-      { success: true, sorted_array: sorted_array }
-    rescue JSON::ParserError => e
-      raise ApiError.new("Failed to parse JSON response: #{e.message}", response)
-    end
-
-    # Validate that the sorted array is valid
-    #
-    # @param sorted_array [Object] Parsed sorted array
-    # @raise [VibeSort::ApiError] if validation fails
-    def validate_sorted_array!(sorted_array)
-      raise ApiError, "Response does not contain a valid 'sorted_array'" unless sorted_array.is_a?(Array)
-
-      return if sorted_array.all? { |item| item.is_a?(Numeric) || item.is_a?(String) }
-
-      raise ApiError, "Sorted array contains invalid values (must be numbers or strings)"
+      PROVIDER_CLASSES.fetch(config.provider).new(config).perform(array)
     end
   end
 end

data/lib/vibe_sort/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module VibeSort
-  VERSION = "0.2.0"
+  VERSION = "0.3.1"
 end

data/lib/vibe_sort.rb

@@ -6,6 +6,12 @@ require "json"
 require_relative "vibe_sort/version"
 require_relative "vibe_sort/error"
 require_relative "vibe_sort/configuration"
+require_relative "vibe_sort/providers/base"
+require_relative "vibe_sort/providers/openai"
+require_relative "vibe_sort/providers/anthropic"
+require_relative "vibe_sort/providers/gemini"
+require_relative "vibe_sort/providers/groq"
+require_relative "vibe_sort/providers/space_x_ai"
 require_relative "vibe_sort/sorter"
 require_relative "vibe_sort/client"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vibe-sort
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Chayut Orapinpatipat
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-10-16 00:00:00.000000000 Z
+date: 2026-07-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -24,8 +24,10 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
-description: A proof-of-concept Ruby gem that sorts number arrays by leveraging the
-  OpenAI Chat Completions API. Demonstrates how AI can be used for computational tasks.
+description: A proof-of-concept Ruby gem that sorts arrays by leveraging LLM APIs
+  (OpenAI Chat Completions, Anthropic Messages, Google Gemini, and the OpenAI-compatible
+  Groq and SpaceXAI Grok APIs). Demonstrates how AI can be used for computational
+  tasks.
 email:
 - chayut_o@hotmail.com
 executables: []
@@ -45,14 +47,18 @@ files:
 - docs/development.md
 - docs/v0.2.0_UPDATE.md
 - lib/vibe/sort.rb
-- lib/vibe/sort/version.rb
 - lib/vibe_sort.rb
 - lib/vibe_sort/client.rb
 - lib/vibe_sort/configuration.rb
 - lib/vibe_sort/error.rb
+- lib/vibe_sort/providers/anthropic.rb
+- lib/vibe_sort/providers/base.rb
+- lib/vibe_sort/providers/gemini.rb
+- lib/vibe_sort/providers/groq.rb
+- lib/vibe_sort/providers/openai.rb
+- lib/vibe_sort/providers/space_x_ai.rb
 - lib/vibe_sort/sorter.rb
 - lib/vibe_sort/version.rb
-- sig/vibe/sort.rbs
 homepage: https://github.com/chayuto/vibe-sort
 licenses:
 - MIT
@@ -60,6 +66,8 @@ metadata:
   homepage_uri: https://github.com/chayuto/vibe-sort
   source_code_uri: https://github.com/chayuto/vibe-sort
   changelog_uri: https://github.com/chayuto/vibe-sort/blob/main/CHANGELOG.md
+  documentation_uri: https://rubydoc.info/gems/vibe-sort
+  bug_tracker_uri: https://github.com/chayuto/vibe-sort/issues
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
@@ -76,8 +84,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
-summary: AI-powered array sorting using OpenAI's GPT models
+summary: AI-powered array sorting using OpenAI, Anthropic Claude, Google Gemini, Groq,
+  or SpaceXAI Grok
 test_files: []

data/lib/vibe/sort/version.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Vibe
-  module Sort
-    VERSION = "0.1.0"
-  end
-end

data/sig/vibe/sort.rbs

@@ -1,6 +0,0 @@
-module Vibe
-  module Sort
-    VERSION: String
-    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
-  end
-end