ruby_llm_community 0.0.6 → 1.1.0

data/lib/ruby_llm/providers/vertexai/models.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class VertexAI
+      # Models methods for the Vertex AI integration
+      module Models
+        # Gemini and other Google models that aren't returned by the API
+        KNOWN_GOOGLE_MODELS = %w[
+          gemini-2.5-flash-lite
+          gemini-2.5-pro
+          gemini-2.5-flash
+          gemini-2.0-flash-lite-001
+          gemini-2.0-flash-001
+          gemini-2.0-flash
+          gemini-2.0-flash-exp
+          gemini-1.5-pro-002
+          gemini-1.5-pro
+          gemini-1.5-flash-002
+          gemini-1.5-flash
+          gemini-1.5-flash-8b
+          gemini-pro
+          gemini-pro-vision
+          gemini-exp-1206
+          gemini-exp-1121
+          gemini-embedding-001
+          text-embedding-005
+          text-embedding-004
+          text-multilingual-embedding-002
+        ].freeze
+
+        def list_models
+          all_models = []
+          page_token = nil
+
+          all_models.concat(build_known_models)
+
+          loop do
+            response = @connection.get('publishers/google/models') do |req|
+              req.headers['x-goog-user-project'] = @config.vertexai_project_id
+              req.params = { pageSize: 100 }
+              req.params[:pageToken] = page_token if page_token
+            end
+
+            publisher_models = response.body['publisherModels'] || []
+            publisher_models.each do |model_data|
+              next if model_data['launchStage'] == 'DEPRECATED'
+
+              model_id = extract_model_id_from_path(model_data['name'])
+              all_models << build_model_from_api_data(model_data, model_id)
+            end
+
+            page_token = response.body['nextPageToken']
+            break unless page_token
+          end
+
+          all_models
+        rescue StandardError => e
+          RubyLLM.logger.debug "Error fetching Vertex AI models: #{e.message}"
+          build_known_models
+        end
+
+        private
+
+        def build_known_models
+          KNOWN_GOOGLE_MODELS.map do |model_id|
+            Model::Info.new(
+              id: model_id,
+              name: model_id,
+              provider: slug,
+              family: determine_model_family(model_id),
+              created_at: nil,
+              context_window: nil,
+              max_output_tokens: nil,
+              modalities: nil,
+              capabilities: %w[streaming function_calling],
+              pricing: nil,
+              metadata: {
+                source: 'known_models'
+              }
+            )
+          end
+        end
+
+        def build_model_from_api_data(model_data, model_id)
+          Model::Info.new(
+            id: model_id,
+            name: model_id,
+            provider: slug,
+            family: determine_model_family(model_id),
+            created_at: nil,
+            context_window: nil,
+            max_output_tokens: nil,
+            modalities: nil,
+            capabilities: extract_capabilities(model_data),
+            pricing: nil,
+            metadata: {
+              version_id: model_data['versionId'],
+              open_source_category: model_data['openSourceCategory'],
+              launch_stage: model_data['launchStage'],
+              supported_actions: model_data['supportedActions'],
+              publisher_model_template: model_data['publisherModelTemplate']
+            }
+          )
+        end
+
+        def extract_model_id_from_path(path)
+          path.split('/').last
+        end
+
+        def determine_model_family(model_id)
+          case model_id
+          when /^gemini-2\.\d+/ then 'gemini-2'
+          when /^gemini-1\.\d+/ then 'gemini-1.5'
+          when /^text-embedding/ then 'text-embedding'
+          when /bison/ then 'palm'
+          else 'gemini'
+          end
+        end
+
+        def extract_capabilities(model_data)
+          capabilities = ['streaming']
+          model_name = model_data['name']
+          capabilities << 'function_calling' if model_name.include?('gemini')
+          capabilities.uniq
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/vertexai/streaming.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class VertexAI
+      # Streaming methods for the Vertex AI implementation
+      module Streaming
+        def stream_url
+          "projects/#{@config.vertexai_project_id}/locations/#{@config.vertexai_location}/publishers/google/models/#{@model}:streamGenerateContent?alt=sse" # rubocop:disable Layout/LineLength
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/vertexai.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    # Google Vertex AI implementation
+    class VertexAI < Gemini
+      include VertexAI::Chat
+      include VertexAI::Streaming
+      include VertexAI::Embeddings
+      include VertexAI::Models
+
+      def initialize(config)
+        super
+        @authorizer = nil
+      end
+
+      def api_base
+        "https://#{@config.vertexai_location}-aiplatform.googleapis.com/v1beta1"
+      end
+
+      def headers
+        {
+          'Authorization' => "Bearer #{access_token}"
+        }
+      end
+
+      class << self
+        def configuration_requirements
+          %i[vertexai_project_id vertexai_location]
+        end
+      end
+
+      private
+
+      def access_token
+        return 'test-token' if defined?(VCR) && !VCR.current_cassette.recording?
+
+        initialize_authorizer unless @authorizer
+        @authorizer.fetch_access_token!['access_token']
+      end
+
+      def initialize_authorizer
+        require 'googleauth'
+        @authorizer = ::Google::Auth.get_application_default(
+          scope: [
+            'https://www.googleapis.com/auth/cloud-platform',
+            'https://www.googleapis.com/auth/generative-language.retriever'
+          ]
+        )
+      rescue LoadError
+        raise Error, 'The googleauth gem is required for Vertex AI. Please add it to your Gemfile: gem "googleauth"'
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/xai/capabilities.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class XAI
+      # Determines capabilities and pricing for xAI (Grok) models
+      # - https://docs.x.ai/docs/models
+      module Capabilities
+        module_function
+
+        # rubocop:disable Naming/VariableNumber
+        MODEL_PATTERNS = {
+          grok_2: /^grok-2(?!-vision)/,
+          grok_2_vision: /^grok-2-vision/,
+          grok_2_image: /^grok-2-image/,
+          grok_3: /^grok-3(?!-(?:fast|mini))/,
+          grok_3_fast: /^grok-3-fast/,
+          grok_3_mini: /^grok-3-mini(?!-fast)/,
+          grok_3_mini_fast: /^grok-3-mini-fast/,
+          grok_4: /^grok-4/
+        }.freeze
+        # rubocop:enable Naming/VariableNumber
+
+        def context_window_for(model_id)
+          case model_family(model_id)
+          when 'grok_4' then 256_000
+          when 'grok_2_vision' then 32_768
+          else 131_072
+          end
+        end
+
+        def max_tokens_for(_model_id)
+          4_096
+        end
+
+        def supports_vision?(model_id)
+          case model_family(model_id)
+          when 'grok_2_vision' then true
+          else false
+          end
+        end
+
+        def supports_functions?(model_id)
+          model_family(model_id) != 'grok_2_image'
+        end
+
+        def supports_structured_output?(model_id)
+          model_family(model_id) != 'grok_2_image'
+        end
+
+        def supports_json_mode?(model_id)
+          supports_structured_output?(model_id)
+        end
+
+        # Pricing from API data (per million tokens)
+        # rubocop:disable Naming/VariableNumber
+        PRICES = {
+          grok_2: { input: 2.0, output: 10.0 },
+          grok_2_vision: { input: 2.0, output: 10.0 },
+          grok_3: { input: 3.0, output: 15.0, cached_input: 0.75 },
+          grok_3_fast: { input: 5.0, output: 25.0, cached_input: 1.25 },
+          grok_3_mini: { input: 0.3, output: 0.5, cached_input: 0.075 },
+          grok_3_mini_fast: { input: 0.6, output: 4.0, cached_input: 0.15 },
+          grok_4: { input: 3.0, output: 15.0, cached_input: 0.75 }
+        }.freeze
+        # rubocop:enable Naming/VariableNumber
+
+        def model_family(model_id)
+          MODEL_PATTERNS.each do |family, pattern|
+            return family.to_s if model_id.match?(pattern)
+          end
+          'other'
+        end
+
+        def input_price_for(model_id)
+          family = model_family(model_id).to_sym
+          prices = PRICES.fetch(family, { input: default_input_price })
+          prices[:input] || default_input_price
+        end
+
+        def cached_input_price_for(model_id)
+          family = model_family(model_id).to_sym
+          prices = PRICES.fetch(family, {})
+          prices[:cached_input]
+        end
+
+        def output_price_for(model_id)
+          family = model_family(model_id).to_sym
+          prices = PRICES.fetch(family, { output: default_output_price })
+          prices[:output] || default_output_price
+        end
+
+        def model_type(model_id)
+          return 'image' if model_family(model_id) == 'grok_2_image'
+
+          'chat'
+        end
+
+        def default_input_price
+          2.0
+        end
+
+        def default_output_price
+          10.0
+        end
+
+        def format_display_name(model_id)
+          model_id.then { |id| humanize(id) }
+                  .then { |name| apply_special_formatting(name) }
+        end
+
+        def humanize(id)
+          id.tr('-', ' ')
+            .split
+            .map(&:capitalize)
+            .join(' ')
+        end
+
+        def apply_special_formatting(name)
+          name
+            .gsub(/^Grok /, 'Grok-')
+            .gsub(/(\d{4}) (\d{2}) (\d{2})/, '\1-\2-\3')
+        end
+
+        def modalities_for(model_id)
+          modalities = {
+            input: ['text'],
+            output: []
+          }
+
+          modalities[:output] << 'text' if model_type(model_id) == 'chat'
+
+          # Vision support
+          modalities[:input] << 'image' if supports_vision?(model_id)
+
+          modalities
+        end
+
+        def capabilities_for(model_id)
+          capabilities = []
+
+          # Common capabilities
+          capabilities << 'streaming'
+          capabilities << 'function_calling' if supports_functions?(model_id)
+          capabilities << 'structured_output' if supports_structured_output?(model_id)
+
+          capabilities
+        end
+
+        def pricing_for(model_id)
+          standard_pricing = {
+            input_per_million: input_price_for(model_id),
+            output_per_million: output_price_for(model_id)
+          }
+
+          # Add cached pricing if available
+          cached_price = cached_input_price_for(model_id)
+          standard_pricing[:cached_input_per_million] = cached_price if cached_price
+
+          # Pricing structure
+          { text_tokens: { standard: standard_pricing } }
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/xai/chat.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class XAI
+      # Chat implementation for xAI
+      # https://docs.x.ai/docs/api-reference#chat-completions
+      module Chat
+        def format_role(role)
+          role.to_s
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/xai/models.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class XAI
+      # Model definitions for xAI API
+      # https://docs.x.ai/docs/api-reference#list-language-models
+      # https://docs.x.ai/docs/api-reference#list-image-generation-models
+      module Models
+        module_function
+
+        # NOTE: We pull models list from two endpoints here as these provide
+        #       detailed, modality, capability and cost information for each
+        #       model that we can leverage which the generic OpenAI compatible
+        #       /models endpoint does not provide.
+        def models_url
+          %w[language-models image-generation-models]
+        end
+
+        def parse_list_models_response(response, slug, capabilities)
+          data = response.body
+          return [] if data.empty?
+
+          data['models']&.map do |model_data|
+            model_id = model_data['id']
+
+            Model::Info.new(
+              id: model_id,
+              name: capabilities.format_display_name(model_id),
+              provider: slug,
+              family: capabilities.model_family(model_id),
+              modalities: {
+                input: model_data['input_modalities'] | capabilities.modalities_for(model_id)[:input],
+                output: model_data['output_modalities'] | capabilities.modalities_for(model_id)[:output]
+              },
+              context_window: capabilities.context_window_for(model_id),
+              capabilities: capabilities.capabilities_for(model_id),
+              pricing: capabilities.pricing_for(model_id),
+              metadata: {
+                aliases: model_data['aliases']
+              }
+            )
+          end || []
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/xai.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    # xAI API integration
+    class XAI < OpenAIBase
+      include XAI::Capabilities
+      include XAI::Chat
+      include XAI::Models
+
+      def api_base
+        'https://api.x.ai/v1'
+      end
+
+      def headers
+        {
+          'Authorization' => "Bearer #{@config.xai_api_key}",
+          'Content-Type' => 'application/json'
+        }
+      end
+
+      # xAI uses a different error format than OpenAI
+      # {"code": "...", "error": "..."}
+      def parse_error(response)
+        return if response.body.empty?
+
+        body = try_parse_json(response.body)
+        case body
+        when Hash then body['error']
+        when Array then body.map { |part| part['error'] }.join('. ')
+        else body
+        end
+      end
+
+      class << self
+        def capabilities
+          XAI::Capabilities
+        end
+
+        def configuration_requirements
+          %i[xai_api_key]
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/railtie.rb

@@ -3,15 +3,31 @@
 module RubyLLM
   # Rails integration for RubyLLM
   class Railtie < Rails::Railtie
+    initializer 'ruby_llm.inflections' do
+      ActiveSupport::Inflector.inflections(:en) do |inflect|
+        inflect.acronym 'LLM'
+      end
+    end
+
     initializer 'ruby_llm.active_record' do
       ActiveSupport.on_load :active_record do
-        include RubyLLM::ActiveRecord::ActsAs
+        if RubyLLM.config.use_new_acts_as
+          require 'ruby_llm/active_record/acts_as'
+          ::ActiveRecord::Base.include RubyLLM::ActiveRecord::ActsAs
+        else
+          require 'ruby_llm/active_record/acts_as_legacy'
+          ::ActiveRecord::Base.include RubyLLM::ActiveRecord::ActsAsLegacy
+
+          Rails.logger.warn(
+            "\n!!! RubyLLM's legacy acts_as API is deprecated and will be removed in RubyLLM 2.0.0. " \
+            "Please consult the migration guide at https://rubyllm.com/upgrading-to-1-7/\n"
+          )
+        end
       end
     end
 
-    # Register generators
-    generators do
-      require 'generators/ruby_llm/install_generator'
+    rake_tasks do
+      load 'tasks/ruby_llm.rake'
     end
   end
 end

data/lib/ruby_llm/stream_accumulator.rb

@@ -2,29 +2,29 @@
 
 module RubyLLM
   # Assembles streaming responses from LLMs into complete messages.
-  # Handles the complexities of accumulating content and tool calls
-  # from partial chunks while tracking token usage.
   class StreamAccumulator
     attr_reader :content, :model_id, :tool_calls
 
     def initialize
-      @content = +''
+      @content = nil
       @tool_calls = {}
       @input_tokens = 0
       @output_tokens = 0
       @cached_tokens = 0
       @cache_creation_tokens = 0
       @latest_tool_call_id = nil
+      @reasoning_id = nil
     end
 
     def add(chunk)
       RubyLLM.logger.debug chunk.inspect if RubyLLM.config.log_stream_debug
       @model_id ||= chunk.model_id
+      @reasoning_id ||= chunk.reasoning_id
 
       if chunk.tool_call?
         accumulate_tool_calls chunk.tool_calls
       else
-        @content << (chunk.content || '')
+        accumulate_content(chunk.content)
       end
 
       count_tokens chunk
@@ -32,27 +32,85 @@ module RubyLLM
     end
 
     def to_message(response)
+      content = final_content
+      associate_reasoning_with_images(content)
+
       Message.new(
         role: :assistant,
-        content: content.empty? ? nil : content,
+        content: content,
         model_id: model_id,
         tool_calls: tool_calls_from_stream,
-        input_tokens: @input_tokens.positive? ? @input_tokens : nil,
-        output_tokens: @output_tokens.positive? ? @output_tokens : nil,
-        cached_tokens: @cached_tokens.positive? ? @cached_tokens : nil,
-        cache_creation_tokens: @cache_creation_tokens.positive? ? @cache_creation_tokens : nil,
+        input_tokens: positive_or_nil(@input_tokens),
+        output_tokens: positive_or_nil(@output_tokens),
+        cached_tokens: positive_or_nil(@cached_tokens),
+        cache_creation_tokens: positive_or_nil(@cache_creation_tokens),
         raw: response
       )
     end
 
     private
 
+    def associate_reasoning_with_images(content)
+      return unless @reasoning_id && content.is_a?(Content) && content.attachments.any?
+
+      content.attachments.each do |attachment|
+        attachment.instance_variable_set(:@reasoning_id, @reasoning_id) if attachment.is_a?(ImageAttachment)
+      end
+    end
+
+    def positive_or_nil(value)
+      value.positive? ? value : nil
+    end
+
+    def accumulate_content(new_content)
+      return unless new_content
+
+      if @content.nil?
+        @content = new_content.is_a?(String) ? +new_content : new_content
+      else
+        case [@content.class, new_content.class]
+        when [String, String]
+          @content << new_content
+        when [String, Content]
+          @content = Content.new(@content)
+          merge_content(new_content)
+        when [Content, String]
+          @content.instance_variable_set(:@text, (@content.text || '') + new_content)
+        when [Content, Content]
+          merge_content(new_content)
+        end
+      end
+    end
+
+    def merge_content(new_content)
+      current_text = @content.text || ''
+      new_text = new_content.text || ''
+      @content.instance_variable_set(:@text, current_text + new_text)
+
+      new_content.attachments.each do |attachment|
+        @content.attach(attachment)
+      end
+    end
+
+    def final_content
+      case @content
+      when nil
+        nil
+      when String
+        @content.empty? ? nil : @content
+      when Content
+        @content.text.nil? && @content.attachments.empty? ? nil : @content
+      else
+        @content
+      end
+    end
+
     def tool_calls_from_stream
       tool_calls.transform_values do |tc|
         arguments = if tc.arguments.is_a?(String) && !tc.arguments.empty?
                       JSON.parse(tc.arguments)
                     elsif tc.arguments.is_a?(String)
-                      {} # Return empty hash for empty string arguments
+                      {}
                     else
                       tc.arguments
                     end