active_genie 0.30.3 → 0.30.8

data/lib/active_genie/logger.rb

@@ -5,32 +5,24 @@ require 'fileutils'
 
 module ActiveGenie
   class Logger
-    def initialize(log_config: nil)
-      @log_config = log_config || ActiveGenie.configuration.log
-    end
-
-    def call(data)
-      log = data.merge(@log_config.additional_context)
+    def call(data, config:)
+      log = data.merge(config.log.additional_context || {})
                 .merge(
                   timestamp: Time.now,
                   process_id: Process.pid
                 )
 
-      persist!(log)
-      output_call(log)
-      call_observers(log)
+      persist!(log, config:)
+      output_call(log, config:)
+      call_observers(log, config:)
 
       log
     end
 
-    def merge(log_config = nil)
-      new(log_config:)
-    end
-
     private
 
-    def call_observers(log)
-      Array(@log_config.observers).each do |observer|
+    def call_observers(log, config:)
+      Array(config.log.observers).each do |observer|
         next unless observer[:scope].all? { |key, value| log[key.to_sym] == value }
 
         observer[:observer]&.call(log)
@@ -39,9 +31,9 @@ module ActiveGenie
       end
     end
 
-    def output_call(log)
-      if @log_config.output
-        @log_config.output&.call(log)
+    def output_call(log, config:)
+      if config.log.output
+        config.log.output&.call(log)
       else
         $stdout.puts log
       end
@@ -49,20 +41,16 @@ module ActiveGenie
       call(code: :output_error, error: e.message)
     end
 
-    def persist!(log)
-      file_path = log_to_file_path(log)
+    def persist!(log, config:)
+      file_path = if log.key?(:fine_tune) && log[:fine_tune]
+                    config.log.fine_tune_file_path
+                  else
+                    config.log.file_path
+                  end
       folder_path = File.dirname(file_path)
 
       FileUtils.mkdir_p(folder_path)
       File.write(file_path, "#{JSON.generate(log)}\n", mode: 'a')
     end
-
-    def log_to_file_path(log)
-      if log.key?(:fine_tune) && log[:fine_tune]
-        @log_config.fine_tune_file_path
-      else
-        @log_config.file_path
-      end
-    end
   end
 end

data/lib/active_genie/providers/anthropic_provider.rb

@@ -30,7 +30,11 @@ module ActiveGenie
           temperature: @config.llm.temperature || 0
         }
 
-        request(payload).dig('content', 0, 'input')
+        response = retry_with_backoff do
+          request(payload)
+        end
+
+        response.dig('content', 0, 'input')
       end
 
       ANTHROPIC_ENDPOINT = '/v1/messages'
@@ -55,7 +59,7 @@ module ActiveGenie
       def request(payload)
         response = post(url, payload, headers:)
 
-        @config.logger.call(
+        ActiveGenie.logger.call(
           {
             code: :llm_usage,
             input_tokens: response.dig('usage', 'input_tokens'),
@@ -65,15 +69,17 @@ module ActiveGenie
                                                                       'output_tokens'),
             model: payload[:model],
             usage: response['usage']
-          }
+          },
+          config: @config
         )
-        @config.logger.call(
+        ActiveGenie.logger.call(
           {
             code: :function_calling,
             fine_tune: true,
             payload:,
             parsed_response: response.dig('content', 0, 'input')
-          }
+          },
+          config: @config
         )
 
         response

data/lib/active_genie/providers/base_provider.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'net/http'
+require_relative '../errors/provider_server_error'
 
 module ActiveGenie
   module Providers
@@ -103,9 +104,7 @@ module ActiveGenie
         http.read_timeout = @config.llm.read_timeout || DEFAULT_TIMEOUT
         http.open_timeout = @config.llm.open_timeout || DEFAULT_OPEN_TIMEOUT
 
-        retry_with_backoff do
-          http.request(request)
-        end
+        http.request(request)
       end
 
       # Apply headers to the request
@@ -153,7 +152,7 @@ module ActiveGenie
       #
       # @param details [Hash] Request and response details
       def log_request_details(uri:, request:, response:, start_time:, parsed_response:)
-        @config.logger.call(
+        ActiveGenie.logger.call(
           {
             code: :http_request,
             uri: uri.to_s,
@@ -161,7 +160,7 @@ module ActiveGenie
             status: response.code,
             duration: Time.now - start_time,
             response_size: parsed_response.to_s.bytesize
-          }
+          }, config: @config
         )
       end
 
@@ -171,23 +170,22 @@ module ActiveGenie
         retries = 0
 
         begin
-          response = yield
-
-          raise ActiveGenie::ProviderServerError, response if response&.code.to_i >= 500
-
-          response
-        rescue Net::OpenTimeout, Net::ReadTimeout, Errno::ECONNREFUSED, ProviderServerError => e
+          yield
+        rescue Net::OpenTimeout, Net::ReadTimeout, Errno::ECONNREFUSED, ActiveGenie::ProviderServerError,
+               JSON::ParserError => e
           raise if retries > max_retries
 
           sleep_time = retry_delay * (2**retries)
           retries += 1
 
-          @config.logger.call(
-            code: :retry_attempt,
-            attempt: retries,
-            max_retries:,
-            next_retry_in_seconds: sleep_time,
-            error: e.message
+          ActiveGenie.logger.call(
+            {
+              code: :retry_attempt,
+              attempt: retries,
+              max_retries:,
+              next_retry_in_seconds: sleep_time,
+              error: e.message
+            }, config: @config
           )
 
           sleep(sleep_time)

data/lib/active_genie/providers/deepseek_provider.rb

@@ -25,14 +25,14 @@ module ActiveGenie
           model:
         }
 
-        response = request(payload)
-
-        if response.nil? || response.keys.empty?
-          raise InvalidResponseError,
-                "Invalid response: #{response}"
+        response = retry_with_backoff do
+          request(payload)
         end
 
-        @config.logger.call({ code: :function_calling, fine_tune: true, payload:, response: })
+        raise InvalidResponseError, "Invalid response: #{response}" if response.keys.empty?
+        raise InvalidResponseError, 'Invalid response: empty' if response.nil?
+
+        ActiveGenie.logger.call({ code: :function_calling, fine_tune: true, payload:, response: }, config: @config)
 
         response
       end
@@ -44,7 +44,7 @@ module ActiveGenie
 
         return nil if response.nil?
 
-        @config.logger.call(
+        ActiveGenie.logger.call(
           {
             code: :llm_usage,
             input_tokens: response.dig('usage', 'prompt_tokens'),
@@ -52,11 +52,19 @@ module ActiveGenie
             total_tokens: response.dig('usage', 'total_tokens'),
             model:,
             usage: response['usage']
-          }
+          }, config: @config
         )
 
-        parsed_response = JSON.parse(response.dig('choices', 0, 'message', 'tool_calls', 0, 'function', 'arguments'))
+        parsed_response = JSON.parse(get_response_body(response))
         parsed_response['message'] || parsed_response
+      rescue JSON::ParserError
+        raise InvalidResponseError, "Invalid response: #{get_response_body(response)}"
+      end
+
+      def get_response_body(response)
+        response.dig('choices', 0, 'message', 'tool_calls', 0, 'function', 'arguments')
+                .gsub(', " "', '')
+                .strip
       end
 
       def function_to_tool(function)

data/lib/active_genie/providers/google_provider.rb

@@ -29,12 +29,17 @@ module ActiveGenie
         }
         params = { key: provider_config.api_key }
 
-        response = request(payload, params)
+        response = retry_with_backoff do
+          request(payload, params)
+        end
 
         json_string = response&.dig('candidates', 0, 'content', 'parts', 0, 'text')
         return nil if json_string.nil? || json_string.empty?
 
-        @config.logger.call({ code: :function_calling, fine_tune: true, payload:, parsed_response: json_string })
+        ActiveGenie.logger.call(
+          { code: :function_calling, fine_tune: true, payload:, parsed_response: json_string },
+          config: @config
+        )
 
         normalize_response(json_string)
       end
@@ -50,7 +55,7 @@ module ActiveGenie
       def request(payload, params)
         response = post(url, payload, headers: DEFAULT_HEADERS, params:)
 
-        @config.logger.call(
+        ActiveGenie.logger.call(
           {
             code: :llm_usage,
             input_tokens: response['usageMetadata']['promptTokenCount'] || 0,
@@ -58,7 +63,8 @@ module ActiveGenie
             total_tokens: response['usageMetadata']['totalTokenCount'] || (prompt_tokens + candidates_tokens),
             model:,
             usage: response['usageMetadata'] || {}
-          }
+          },
+          config: @config
         )
 
         response

data/lib/active_genie/providers/openai_provider.rb

@@ -25,11 +25,13 @@ module ActiveGenie
           model:
         }
 
-        response = request(payload)
+        response = retry_with_backoff do
+          request(payload)
+        end
 
         raise InvalidResponseError, "Invalid response: #{response}" if response.nil? || response.keys.empty?
 
-        @config.logger.call({ code: :function_calling, fine_tune: true, payload:, response: })
+        ActiveGenie.logger.call({ code: :function_calling, fine_tune: true, payload:, response: }, config: @config)
 
         response
       end
@@ -41,7 +43,7 @@ module ActiveGenie
 
         return nil if response.nil?
 
-        @config.logger.call(
+        ActiveGenie.logger.call(
           {
             code: :llm_usage,
             input_tokens: response.dig('usage', 'prompt_tokens'),
@@ -49,7 +51,7 @@ module ActiveGenie
             total_tokens: response.dig('usage', 'total_tokens'),
             model:,
             usage: response['usage']
-          }
+          }, config: @config
         )
 
         parsed_response = JSON.parse(response.dig('choices', 0, 'message', 'tool_calls', 0, 'function', 'arguments'))

data/lib/active_genie/providers/unified_provider.rb

@@ -6,6 +6,7 @@ require_relative 'google_provider'
 require_relative 'deepseek_provider'
 require_relative '../errors/invalid_provider_error'
 require_relative '../errors/invalid_model_error'
+require_relative '../errors/without_available_provider_error'
 
 module ActiveGenie
   module Providers
@@ -19,8 +20,13 @@ module ActiveGenie
         }.freeze
 
         def function_calling(messages, function, config: {})
-          provider = provider(config)
-          define_llm_model(config)
+          model, provider_name = model_and_provider_by(config)
+
+          provider = PROVIDER_NAME_TO_PROVIDER[provider_name&.to_sym]
+
+          raise ActiveGenie::WithoutAvailableProviderError if provider.nil?
+
+          config.llm.model = model
 
           response = provider.new(config).function_calling(messages, function)
 
@@ -29,30 +35,54 @@ module ActiveGenie
 
         private
 
-        def provider(config)
-          provider_name = config.llm.provider_name || config.providers.default
+        # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+        def model_and_provider_by(config)
+          model, provider_name = explicit_choice(config)
+          model, provider_name = global_default(config) if model.nil? && provider_name.nil?
+          model, provider_name = module_recommendation(config) if model.nil? && provider_name.nil?
 
-          unless config.providers.valid.keys.include?(provider_name.to_sym)
-            raise ActiveGenie::InvalidProviderError,
-                  provider_name
-          end
+          model, provider_name = infer_from_partial(config, model, provider_name) if model.nil? || provider_name.nil?
+          model, provider_name = any_available(config) if model.nil? || provider_name.nil?
 
-          provider = PROVIDER_NAME_TO_PROVIDER[provider_name.to_sym]
+          [model, provider_name]
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
 
-          raise ActiveGenie::InvalidProviderError, provider_name if provider.nil?
+        def explicit_choice(config)
+          model = config.llm.model
+          provider_name = config.providers.default
 
-          provider
+          [model, provider_name]
         end
 
-        def define_llm_model(config)
-          if config.llm.model.nil?
-            raise ActiveGenie::InvalidModelError, 'nil' unless config.llm.recommended_model
+        def global_default(config)
+          provider_name = config.providers.default
 
-            config.llm.model = config.llm.recommended_model
+          [nil, provider_name]
+        end
 
-          end
+        def module_recommendation(config)
+          model = config.llm.recommended_model
+          provider_name = config.providers.provider_name_by_model(model) if model
+
+          return nil if model.nil? || provider_name.nil?
+
+          [model, provider_name]
+        end
+
+        def infer_from_partial(config, model, provider_name)
+          provider_name ||= config.providers.provider_name_by_model(model) if model
+          model ||= config.providers.valid[provider_name.to_sym]&.default_model if provider_name
+
+          [model, provider_name]
+        end
+
+        def any_available(config)
+          provider = config.providers.valid.first
+          provider_name = provider&.first
+          model = provider&.last&.default_model
 
-          config.llm.model
+          [model, provider_name]
         end
 
         def normalize_response(response)

data/lib/active_genie/ranker/elo.rb

@@ -12,7 +12,7 @@ module ActiveGenie
         @higher_tier = players.calc_higher_tier
         @lower_tier = players.calc_lower_tier
         @criteria = criteria
-        @config = ActiveGenie.configuration.merge(config)
+        @initial_config = config
         @tmp_highers = []
         @total_tokens = 0
         @previous_elo = @players.to_h { |player| [player.id, player.elo] }
@@ -20,16 +20,16 @@ module ActiveGenie
       end
 
       def call
-        @config.log.add_observer(observers: ->(log) { log_observer(log) })
-        @config.log.additional_context = { elo_id: }
+        config.log.add_observer(observers: ->(log) { log_observer(log) })
+        config.log.additional_context = { elo_id: }
 
-        ActiveGenie::FiberByBatch.call(matches, config: @config) do |player_a, player_b|
+        ActiveGenie::FiberByBatch.call(matches, config:) do |player_a, player_b|
           winner, loser = debate(player_a, player_b)
 
           update_players_elo(winner, loser)
         end
 
-        build_report
+        elo_result
       end
 
       DEBATE_PER_PLAYER = 3
@@ -38,39 +38,37 @@ module ActiveGenie
       private
 
       def matches
-        match_keys = {}
-
-        @higher_tier.each_with_object([]) do |attack_player, matches|
+        @matches ||= @lower_tier.each_with_object([]) do |lower_player, matches|
           DEBATE_PER_PLAYER.times do
             higher_player = next_higher_player
 
-            next if match_keys["#{attack_player.id}_#{higher_player.id}"]
+            next if matches.include?([lower_player, higher_player])
 
-            match_keys["#{attack_player.id}_#{higher_player.id}"] = true
-            matches << [attack_player, higher_player]
+            matches << [lower_player, higher_player]
           end
         end
       end
 
       def next_higher_player
-        @tmp_highers = @higher_tier.shuffle if @tmp_highers.empty?
+        @tmp_highers = @higher_tier.dup if @tmp_highers.empty?
 
-        @tmp_highers.pop
+        @tmp_highers.count % 2 ? @tmp_highers.shift : @tmp_highers.pop
       end
 
       def debate(player_a, player_b)
+        debate_config = ActiveGenie::DeepMerge.call(
+          config.to_h,
+          { log: { additional_context: { player_a_id: player_a.id, player_b_id: player_b.id } } }
+        )
+
         result = ActiveGenie::Comparator.by_debate(
           player_a.content,
           player_b.content,
           @criteria,
-          config: @config.merge(additional_context: { player_a_id: player_a.id, player_b_id: player_b.id })
+          config: ActiveGenie.new_configuration(debate_config)
         )
 
-        winner, loser = case result['winner']
-                        when 'player_a' then [player_a, player_b]
-                        when 'player_b' then [player_b, player_a]
-                        when 'draw' then [nil, nil]
-                        end
+        winner, loser = result.data == player_a.content ? [player_a, player_b] : [player_b, player_a]
 
         [winner, loser]
       end
@@ -94,27 +92,30 @@ module ActiveGenie
           higher_tier_ids = @higher_tier.map(&:id).join(',')
           lower_tier_ids = @lower_tier.map(&:id).join(',')
 
-          ranker_unique_key = [higher_tier_ids, lower_tier_ids, @criteria, @config.to_json].join('-')
+          ranker_unique_key = [higher_tier_ids, lower_tier_ids, @criteria].join('-')
           Digest::MD5.hexdigest(ranker_unique_key)
         end
       end
 
-      def build_report
-        report = {
-          elo_id:,
-          players_in: players_in.map(&:id),
-          debates_count: matches.size,
-          total_tokens: @total_tokens,
-          players_in_round: players_in.map(&:id),
-          previous_highest_elo: @previous_highest_elo,
-          highest_elo:,
-          highest_elo_diff: highest_elo - @previous_highest_elo,
-          players_elo_diff:
-        }
-
-        @config.logger.call({ elo_id:, code: :elo_report, **report })
-
-        report
+      def elo_result
+        result = ActiveGenie::Result.new(
+          data: @players.sorted.map(&:content),
+          metadata: {
+            elo_id:,
+            players: @players,
+            players_in_round: players_in.map(&:id),
+            debates_count: matches.size,
+            total_tokens: @total_tokens,
+            previous_highest_elo: @previous_highest_elo,
+            highest_elo:,
+            highest_elo_diff: highest_elo - @previous_highest_elo,
+            players_elo_diff:
+          }
+        )
+
+        ActiveGenie.logger.call({ elo_id:, code: :elo_report, **result.metadata }, config:)
+
+        result
       end
 
       def players_in
@@ -135,6 +136,10 @@ module ActiveGenie
       def log_observer(log)
         @total_tokens += log[:total_tokens] if log[:code] == :llm_usage
       end
+
+      def config
+        @config ||= ActiveGenie.new_configuration(@initial_config)
+      end
     end
   end
 end

data/lib/active_genie/ranker/free_for_all.rb

@@ -10,22 +10,19 @@ module ActiveGenie
       def initialize(players, criteria, config: nil)
         @players = Entities::Players.new(players)
         @criteria = criteria
-        @config = config || ActiveGenie.configuration
+        @initial_config = config
         @start_time = Time.now
         @total_tokens = 0
       end
 
       def call
-        @config.log.add_observer(observers: ->(log) { log_observer(log) })
-        @config.log.additional_context = { free_for_all_id: }
-
-        ActiveGenie::FiberByBatch.call(matches, config: @config) do |player_a, player_b|
+        ActiveGenie::FiberByBatch.call(matches, config:) do |player_a, player_b|
           winner, loser = debate(player_a, player_b)
 
           update_players_score(winner, loser)
         end
 
-        build_report
+        build_result
       end
 
       private
@@ -37,29 +34,32 @@ module ActiveGenie
       end
 
       def debate(player_a, player_b)
-        log_context = { player_a_id: player_a.id, player_b_id: player_b.id }
+        debate_config = ActiveGenie::DeepMerge.call(
+          config.to_h,
+          { log: { additional_context: { player_a_id: player_a.id, player_b_id: player_b.id } } }
+        )
 
         result = ActiveGenie::Comparator.by_debate(
           player_a.content,
           player_b.content,
           @criteria,
-          config: @config.merge(additional_context: log_context)
+          config: ActiveGenie.new_configuration(debate_config)
         )
 
-        winner, loser = case result['winner']
-                        when 'player_a' then [player_a, player_b]
-                        when 'player_b' then [player_b, player_a]
-                        when 'draw' then [nil, nil]
+        winner, loser = case result.data
+                        when player_a.to_s then [player_a, player_b]
+                        else [player_b, player_a]
                         end
 
-        @config.logger.call(
+        ActiveGenie.logger.call(
           {
-            **log_context,
+            player_a_id: player_a.id,
+            player_b_id: player_b.id,
             code: :free_for_all,
-            winner_id: winner&.id,
-            loser_id: loser&.id,
-            reasoning: result['reasoning']
-          }
+            winner: winner.to_s[0..20],
+            loser: loser.to_s[0..20],
+            reasoning: result.reasoning
+          }, config:
         )
 
         [winner, loser]
@@ -80,27 +80,44 @@ module ActiveGenie
       def free_for_all_id
         @free_for_all_id ||= begin
           eligible_ids = @players.eligible.map(&:id).join(',')
-          ranking_unique_key = [eligible_ids, @criteria, @config.to_json].join('-')
+          ranking_unique_key = [eligible_ids, @criteria].join('-')
           Digest::MD5.hexdigest(ranking_unique_key)
         end
       end
 
-      def build_report
-        report = {
-          free_for_all_id:,
-          debates_count: matches.size,
-          duration_seconds: Time.now - @start_time,
-          total_tokens: @total_tokens
-        }
+      def build_result
+        result = ActiveGenie::Result.new(
+          data: @players.sorted.map(&:content),
+          metadata: {
+            free_for_all_id:,
+            players: @players,
+            debates_count: matches.size,
+            duration_seconds: Time.now - @start_time,
+            total_tokens: @total_tokens
+          }
+        )
 
-        @config.logger.call({ code: :free_for_all_report, **report })
+        ActiveGenie.logger.call({ code: :free_for_all_report, **result.metadata }, config:)
 
-        report
+        result
       end
 
       def log_observer(log)
         @total_tokens += log[:total_tokens] if log[:code] == :llm_usage
       end
+
+      def config
+        @config ||= begin
+          c = ActiveGenie.new_configuration(
+            ActiveGenie::DeepMerge.call(
+              @initial_config.to_h,
+              { log: { context: { free_for_all_id: } } }
+            )
+          )
+          c.log.add_observer(observers: ->(log) { log_observer(log) })
+          c
+        end
+      end
     end
   end
 end