ruby_llm_swarm 1.9.1

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

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Perplexity
+      # Determines capabilities and pricing for Perplexity models
+      module Capabilities
+        module_function
+
+        def context_window_for(model_id)
+          case model_id
+          when /sonar-pro/ then 200_000
+          else 128_000
+          end
+        end
+
+        def max_tokens_for(model_id)
+          case model_id
+          when /sonar-(?:pro|reasoning-pro)/ then 8_192
+          else 4_096
+          end
+        end
+
+        def input_price_for(model_id)
+          PRICES.dig(model_family(model_id), :input) || 1.0
+        end
+
+        def output_price_for(model_id)
+          PRICES.dig(model_family(model_id), :output) || 1.0
+        end
+
+        def supports_vision?(model_id)
+          case model_id
+          when /sonar-reasoning-pro/, /sonar-reasoning/, /sonar-pro/, /sonar/ then true
+          else false
+          end
+        end
+
+        def supports_functions?(_model_id)
+          false
+        end
+
+        def supports_json_mode?(_model_id)
+          true
+        end
+
+        def format_display_name(model_id)
+          case model_id
+          when 'sonar' then 'Sonar'
+          when 'sonar-pro' then 'Sonar Pro'
+          when 'sonar-reasoning' then 'Sonar Reasoning'
+          when 'sonar-reasoning-pro' then 'Sonar Reasoning Pro'
+          when 'sonar-deep-research' then 'Sonar Deep Research'
+          else
+            model_id.split('-')
+                    .map(&:capitalize)
+                    .join(' ')
+          end
+        end
+
+        def model_type(_model_id)
+          'chat'
+        end
+
+        def model_family(model_id)
+          case model_id
+          when 'sonar' then :sonar
+          when 'sonar-pro' then :sonar_pro
+          when 'sonar-reasoning' then :sonar_reasoning
+          when 'sonar-reasoning-pro' then :sonar_reasoning_pro
+          when 'sonar-deep-research' then :sonar_deep_research
+          else :unknown
+          end
+        end
+
+        def modalities_for(_model_id)
+          {
+            input: ['text'],
+            output: ['text']
+          }
+        end
+
+        def capabilities_for(model_id)
+          capabilities = %w[streaming json_mode]
+          capabilities << 'vision' if supports_vision?(model_id)
+          capabilities
+        end
+
+        def pricing_for(model_id)
+          family = model_family(model_id)
+          prices = PRICES.fetch(family, { input: 1.0, output: 1.0 })
+
+          standard_pricing = {
+            input_per_million: prices[:input],
+            output_per_million: prices[:output]
+          }
+
+          standard_pricing[:citation_per_million] = prices[:citation] if prices[:citation]
+          standard_pricing[:reasoning_per_million] = prices[:reasoning] if prices[:reasoning]
+          standard_pricing[:search_per_thousand] = prices[:search_queries] if prices[:search_queries]
+
+          {
+            text_tokens: {
+              standard: standard_pricing
+            }
+          }
+        end
+
+        PRICES = {
+          sonar: {
+            input: 1.0,
+            output: 1.0
+          },
+          sonar_pro: {
+            input: 3.0,
+            output: 15.0
+          },
+          sonar_reasoning: {
+            input: 1.0,
+            output: 5.0
+          },
+          sonar_reasoning_pro: {
+            input: 2.0,
+            output: 8.0
+          },
+          sonar_deep_research: {
+            input: 2.0,
+            output: 8.0,
+            citation: 2.0,
+            reasoning: 3.0,
+            search_queries: 5.0
+          }
+        }.freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Perplexity
+      # Chat formatting for Perplexity provider
+      module Chat
+        module_function
+
+        def format_role(role)
+          role.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Perplexity
+      # Models methods of the Perplexity API integration
+      module Models
+        def list_models(**)
+          slug = 'perplexity'
+          capabilities = Perplexity::Capabilities
+          parse_list_models_response(nil, slug, capabilities)
+        end
+
+        def parse_list_models_response(_response, slug, capabilities)
+          [
+            create_model_info('sonar', slug, capabilities),
+            create_model_info('sonar-pro', slug, capabilities),
+            create_model_info('sonar-reasoning', slug, capabilities),
+            create_model_info('sonar-reasoning-pro', slug, capabilities),
+            create_model_info('sonar-deep-research', slug, capabilities)
+          ]
+        end
+
+        def create_model_info(id, slug, capabilities)
+          Model::Info.new(
+            id: id,
+            name: capabilities.format_display_name(id),
+            provider: slug,
+            family: capabilities.model_family(id).to_s,
+            created_at: Time.now,
+            context_window: capabilities.context_window_for(id),
+            max_output_tokens: capabilities.max_tokens_for(id),
+            modalities: capabilities.modalities_for(id),
+            capabilities: capabilities.capabilities_for(id),
+            pricing: capabilities.pricing_for(id),
+            metadata: {}
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/perplexity.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    # Perplexity API integration.
+    class Perplexity < OpenAI
+      include Perplexity::Chat
+      include Perplexity::Models
+
+      def api_base
+        'https://api.perplexity.ai'
+      end
+
+      def headers
+        {
+          'Authorization' => "Bearer #{@config.perplexity_api_key}",
+          'Content-Type' => 'application/json'
+        }
+      end
+
+      class << self
+        def capabilities
+          Perplexity::Capabilities
+        end
+
+        def configuration_requirements
+          %i[perplexity_api_key]
+        end
+      end
+
+      def parse_error(response)
+        body = response.body
+        return if body.empty?
+
+        # If response is HTML (Perplexity returns HTML for auth errors)
+        if body.include?('<html>') && body.include?('<title>')
+          title_match = body.match(%r{<title>(.+?)</title>})
+          if title_match
+            message = title_match[1]
+            message = message.sub(/^\d+\s+/, '')
+            return message
+          end
+        end
+        super
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class VertexAI
+      # Embeddings methods for the Vertex AI implementation
+      module Embeddings
+        module_function
+
+        def embedding_url(model:)
+          "projects/#{@config.vertexai_project_id}/locations/#{@config.vertexai_location}/publishers/google/models/#{model}:predict" # rubocop:disable Layout/LineLength
+        end
+
+        def render_embedding_payload(text, model:, dimensions:) # rubocop:disable Lint/UnusedMethodArgument
+          {
+            instances: [text].flatten.map { |t| { content: t.to_s } }
+          }.tap do |payload|
+            payload[:parameters] = { outputDimensionality: dimensions } if dimensions
+          end
+        end
+
+        def parse_embedding_response(response, model:, text:)
+          predictions = response.body['predictions']
+          vectors = predictions&.map { |p| p.dig('embeddings', 'values') }
+          vectors = vectors.first if vectors&.length == 1 && !text.is_a?(Array)
+
+          Embedding.new(vectors:, model:, input_tokens: 0)
+        end
+      end
+    end
+  end
+end

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/transcription.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class VertexAI
+      # Vertex AI specific helpers for audio transcription
+      module Transcription
+        private
+
+        def transcription_url(model)
+          "projects/#{@config.vertexai_project_id}/locations/#{@config.vertexai_location}/publishers/google/models/#{model}:generateContent" # 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
+      include VertexAI::Transcription
+
+      def initialize(config)
+        super
+        @authorizer = nil
+      end
+
+      def api_base
+        "https://#{@config.vertexai_location}-aiplatform.googleapis.com/v1beta1"
+      end
+
+      def headers
+        if defined?(VCR) && !VCR.current_cassette.recording?
+          { 'Authorization' => 'Bearer test-token' }
+        else
+          initialize_authorizer unless @authorizer
+          @authorizer.apply({})
+        end
+      rescue Google::Auth::AuthorizationError => e
+        raise UnauthorizedError.new(nil, "Invalid Google Cloud credentials for Vertex AI: #{e.message}")
+      end
+
+      class << self
+        def configuration_requirements
+          %i[vertexai_project_id vertexai_location]
+        end
+      end
+
+      private
+
+      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 ~> 1.15 is required for Vertex AI. Please add it to your Gemfile: gem "googleauth"'
+      end
+    end
+  end
+end

data/lib/ruby_llm/railtie.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+if defined?(Rails::Railtie)
+  module RubyLLM
+    # Rails integration for RubyLLM
+    class Railtie < Rails::Railtie
+      initializer 'ruby_llm.inflections' do
+        ActiveSupport::Inflector.inflections(:en) do |inflect|
+          inflect.acronym 'RubyLLM'
+        end
+      end
+
+      initializer 'ruby_llm.active_record' do
+        ActiveSupport.on_load :active_record do
+          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
+
+      rake_tasks do
+        load 'tasks/ruby_llm.rake'
+      end
+    end
+  end
+end

data/lib/ruby_llm/responses_session.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  # Manages state for OpenAI Responses API stateful conversations.
+  # Tracks response IDs, session validity, and failure recovery.
+  class ResponsesSession
+    RESPONSE_ID_TTL = 300 # 5 minutes
+    MAX_FAILURES = 2
+
+    attr_reader :response_id, :last_activity, :failure_count
+
+    def initialize(response_id: nil, last_activity: nil, failure_count: 0, disabled: false)
+      @response_id = response_id
+      @last_activity = last_activity
+      @failure_count = failure_count
+      @disabled = disabled
+    end
+
+    def reset!
+      @response_id = nil
+      @last_activity = nil
+      @failure_count = 0
+      @disabled = false
+    end
+
+    def update(new_response_id)
+      @response_id = new_response_id
+      @last_activity = Time.now
+      @failure_count = 0
+    end
+
+    def valid?
+      return false if @disabled
+      return false unless @response_id
+      return false unless @last_activity
+
+      (Time.now - @last_activity) < RESPONSE_ID_TTL
+    end
+
+    def record_failure!
+      @failure_count += 1
+
+      if @failure_count >= MAX_FAILURES
+        @disabled = true
+      else
+        # Reset response_id and last_activity but preserve failure_count
+        @response_id = nil
+        @last_activity = nil
+      end
+    end
+
+    def disabled?
+      @disabled
+    end
+
+    def to_h
+      {
+        response_id: @response_id,
+        last_activity: @last_activity&.iso8601,
+        failure_count: @failure_count,
+        disabled: @disabled
+      }
+    end
+
+    def self.from_h(hash)
+      hash = hash.transform_keys(&:to_sym)
+      last_activity = hash[:last_activity] ? Time.parse(hash[:last_activity]) : nil
+
+      new(
+        response_id: hash[:response_id],
+        last_activity: last_activity,
+        failure_count: hash[:failure_count] || 0,
+        disabled: hash[:disabled] || false
+      )
+    end
+  end
+end