active_genie 0.30.1 → 0.30.8

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

data/lib/active_genie/ranker/scoring.rb

@@ -12,14 +12,12 @@ module ActiveGenie
       def initialize(players, criteria, juries: [], config: nil)
         @players = Entities::Players.new(players)
         @criteria = criteria
-        @config = ActiveGenie.configuration.merge(config)
+        @initial_config = config
         @juries = Array(juries).compact.uniq
       end
 
       def call
-        @config.log.additional_context = { ranker_scoring_id: }
-
-        ActiveGenie::FiberByBatch.call(players_without_score, config: @config) do |player|
+        ActiveGenie::FiberByBatch.call(players_without_score, config:) do |player|
           player.score = generate_score(player)
         end
       end
@@ -31,14 +29,16 @@ module ActiveGenie
       end
 
       def generate_score(player)
-        score, reasoning = ActiveGenie::Scorer.by_jury_bench(
+        result = ActiveGenie::Scorer.by_jury_bench(
           player.content,
           @criteria,
           @juries,
-          config: @config
-        ).values_at('final_score', 'final_reasoning')
+          config:
+        )
+        score = result.data.to_i
+        reasoning = result.reasoning
 
-        @config.logger.call({ code: :new_score, player_id: player.id, score:, reasoning: })
+        ActiveGenie.logger.call({ code: :new_score, player_id: player.id, score:, reasoning: }, config:)
 
         score
       end
@@ -48,9 +48,9 @@ module ActiveGenie
           response = ActiveGenie::Lister.juries(
             [@players.sample.content, @players.sample.content].join("\n\n"),
             @criteria,
-            config: @config
+            config:
           )
-          @config.logger.call({ code: :new_juries, juries: response })
+          ActiveGenie.logger.call({ code: :new_juries, juries: response }, config:)
           response
         end
       end
@@ -58,11 +58,20 @@ module ActiveGenie
       def ranker_scoring_id
         @ranker_scoring_id ||= begin
           player_ids = players_without_score.map(&:id).join(',')
-          ranker_unique_key = [player_ids, @criteria, @config.to_json].join('-')
+          ranker_unique_key = [player_ids, @criteria].join('-')
 
           "#{Digest::MD5.hexdigest(ranker_unique_key)}-scoring"
         end
       end
+
+      def config
+        @config ||= ActiveGenie.new_configuration(
+          DeepMerge.call(
+            @initial_config,
+            { log: { additional_context: { ranker_scoring_id: } } }
+          )
+        )
+      end
     end
   end
 end

data/lib/active_genie/ranker/tournament.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'entities/players'
+require_relative '../entities/players'
 require_relative 'free_for_all'
 require_relative 'elo'
 require_relative 'scoring'
@@ -30,33 +30,30 @@ require_relative 'scoring'
 # @return [Hash] Final ranked player results
 module ActiveGenie
   module Ranker
-    class Tournament
-      def self.call(...)
-        new(...).call
-      end
-
+    class Tournament < ActiveGenie::BaseModule
       def initialize(players, criteria, juries: [], config: {})
         @players = Entities::Players.new(players)
         @criteria = criteria
         @juries = Array(juries).compact.uniq
-        @config = ActiveGenie.configuration.merge(config)
+        super(config:)
       end
 
       def call
-        @config.log.additional_context = { ranker_id: }
-
         set_initial_player_scores!
         eliminate_obvious_bad_players!
 
         while @players.elo_eligible?
-          elo_report = run_elo_round!
+          elo_result = run_elo_round!
           eliminate_lower_tier_players!
-          rebalance_players!(elo_report)
+          rebalance_players!(elo_result)
         end
 
         run_free_for_all!
 
-        sorted_players
+        ActiveGenie::Result.new(
+          data: sorted_players.map(&:content),
+          metadata: @players.map(&:to_h)
+        )
       end
 
       ELIMINATION_VARIATION = 'variation_too_high'
@@ -65,12 +62,7 @@ module ActiveGenie
       private
 
       def set_initial_player_scores!
-        Scoring.call(
-          @players,
-          @criteria,
-          juries: @juries,
-          config: @config
-        )
+        Scoring.call(@players, @criteria, juries: @juries, config:)
       end
 
       def eliminate_obvious_bad_players!
@@ -80,50 +72,46 @@ module ActiveGenie
       end
 
       def run_elo_round!
-        Elo.call(
-          @players,
-          @criteria,
-          config: @config
-        )
+        Elo.call(@players, @criteria, config:)
       end
 
       def eliminate_lower_tier_players!
         @players.calc_lower_tier.each { |player| player.eliminated = ELIMINATION_RELEGATION }
       end
 
-      def rebalance_players!(elo_report)
-        return if elo_report[:highest_elo_diff].negative?
+      def rebalance_players!(elo_result)
+        return if elo_result.metadata[:highest_elo_diff].negative?
 
         @players.eligible.each do |player|
-          next if elo_report[:players_in_round].include?(player.id)
+          next if elo_result.metadata[:players_in_round].include?(player.id)
 
-          player.elo += elo_report[:highest_elo_diff]
+          player.elo += elo_result.metadata[:highest_elo_diff]
         end
       end
 
       def run_free_for_all!
-        FreeForAll.call(
-          @players,
-          @criteria,
-          config: @config
-        )
+        FreeForAll.call(@players, @criteria, config:)
       end
 
       def sorted_players
         players = @players.sorted
-        @config.logger.call({ ranker_id:, code: :ranker_final, players: players.map(&:to_h) })
+        ActiveGenie.logger.call({ ranker_id:, code: :ranker_final, players: players.map(&:to_h) }, config:)
 
-        players.map(&:to_h)
+        players
       end
 
       def ranker_id
         @ranker_id ||= begin
           player_ids = @players.map(&:id).join(',')
-          ranker_unique_key = [player_ids, @criteria, @config.to_json].join('-')
+          ranker_unique_key = [player_ids, @criteria].join('-')
 
           Digest::MD5.hexdigest(ranker_unique_key)
         end
       end
+
+      def module_config
+        { log: { additional_context: { ranker_id: } } }
+      end
     end
   end
 end

data/lib/active_genie/scorer/jury_bench.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../providers/unified_provider'
+require_relative '../utils/text_case'
 
 module ActiveGenie
   module Scorer
@@ -17,7 +18,7 @@ module ActiveGenie
     # @example Usage with automatic jury recommendation
     #   JuryBench.call("Sample text", "Evaluate technical accuracy")
     #
-    class JuryBench
+    class JuryBench < ActiveGenie::BaseModule
       # @param text [String] The text content to be evaluated
       # @param criteria [String] The evaluation criteria or rubric to assess against
       # @param juries [Array<String>] Optional list of specific juries. If empty,
@@ -26,15 +27,11 @@ module ActiveGenie
       # @return [Hash] The evaluation result containing the scores and reasoning
       #   @return [Number] :final_score The final score of the text based on the criteria and juries
       #   @return [String] :final_reasoning Detailed explanation of why the final score was reached
-      def self.call(...)
-        new(...).call
-      end
-
       def initialize(text, criteria, juries = [], config: {})
         @text = text
         @criteria = criteria
         @param_juries = Array(juries).compact.uniq
-        @config = ActiveGenie.configuration.merge(config)
+        super(config:)
       end
 
       def call
@@ -44,24 +41,17 @@ module ActiveGenie
           {  role: 'user', content: "Text to score: #{@text}" }
         ]
 
-        result = ::ActiveGenie::Providers::UnifiedProvider.function_calling(
+        provider_response = ::ActiveGenie::Providers::UnifiedProvider.function_calling(
           messages,
           build_function,
-          config: @config
+          config:
         )
 
-        result['final_score'] = 0 if result['final_score'].nil?
-
-        @config.logger.call({
-                              code: :Scorer,
-                              text: @text[0..30],
-                              criteria: @criteria[0..30],
-                              juries: juries,
-                              score: result['final_score'],
-                              reasoning: result['final_reasoning']
-                            })
-
-        result
+        ActiveGenie::Result.new(
+          data: provider_response['final_score'] || 0,
+          reasoning: provider_response['final_reasoning'],
+          metadata: provider_response
+        )
       end
 
       PROMPT = File.read(File.join(__dir__, 'jury_bench.prompt.md'))
@@ -84,11 +74,12 @@ module ActiveGenie
         @properties ||= begin
           tmp = {}
           juries.each do |jury|
-            tmp["#{jury}_reasoning"] = {
+            jury_key = ActiveGenie::TextCase.underscore(jury)
+            tmp["#{jury_key}_reasoning"] = {
               type: 'string',
               description: "The reasoning of the Scorer process by #{jury}."
             }
-            tmp["#{jury}_score"] = {
+            tmp["#{jury_key}_score"] = {
               type: 'number',
               description: "The score given by #{jury}.",
               min: 0,
@@ -113,9 +104,13 @@ module ActiveGenie
         @juries ||= if @param_juries.any?
                       @param_juries
                     else
-                      ::ActiveGenie::Lister::Juries.call(@text, @criteria, config: @config)
+                      ::ActiveGenie::Lister::Juries.call(@text, @criteria, config:).data
                     end
       end
+
+      def module_config
+        { llm: { recommended_model: 'deepseek-chat' } }
+      end
     end
   end
 end

data/lib/active_genie/utils/base_module.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'call_wrapper'
+
+module ActiveGenie
+  class BaseModule
+    prepend CallWrapper
+
+    def self.call(...)
+      new(...).call
+    end
+
+    def initialize(config: {})
+      @initial_config = config || {}
+    end
+
+    def call
+      raise NotImplementedError, 'Subclasses must implement the `call` method'
+    end
+
+    def config
+      @config ||= ActiveGenie.new_configuration(
+        ActiveGenie::DeepMerge.call(
+          @initial_config.to_h,
+          module_config
+        )
+      )
+    end
+
+    def module_config
+      {}
+    end
+  end
+end

data/lib/active_genie/utils/call_wrapper.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ActiveGenie
+  module CallWrapper
+    def call(*, &)
+      response = super # Call the original method
+
+      if defined?(config)
+        ActiveGenie.logger.call(
+          {
+            code: self.class.name,
+            response: response.to_h
+          }, config:
+        )
+      end
+
+      response
+    end
+  end
+end

data/lib/active_genie/utils/deep_merge.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ActiveGenie
+  module DeepMerge
+    module_function
+
+    def call(first_hash, second_hash)
+      merger = proc { |_key, v1, v2| v1.is_a?(Hash) && v2.is_a?(Hash) ? v1.merge(v2, &merger) : v2 }
+      first_hash.to_h.merge(second_hash.to_h, &merger)
+    end
+  end
+end

data/lib/active_genie/utils/fiber_by_batch.rb

@@ -8,9 +8,9 @@ module ActiveGenie
 
     def call(items, config:, &block)
       items.each_slice(config.llm.max_fibers).to_a.each do |batch|
-        Async do
+        Async do |task|
           tasks = batch.map do |item|
-            Async { block.call(item) }
+            task.async { block.call(item) }
           end
 
           tasks.each(&:wait)

data/lib/active_genie/utils/text_case.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ActiveGenie
+  module TextCase
+    module_function
+
+    def underscore(camel_cased_word)
+      return camel_cased_word.to_s.dup unless /[A-Z-]|::/.match?(camel_cased_word)
+
+      word = camel_cased_word.to_s.gsub('::', '/')
+      word.gsub!(/(?<=[A-Z])(?=[A-Z][a-z])|(?<=[a-z\d])(?=[A-Z])/, '_')
+      word.tr!('-', '_')
+      word.tr!(' ', '_')
+      word.downcase!
+      word
+    end
+  end
+end