active_genie 0.26.6 → 0.28.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47ad459a3acb6b1e37b8cc9d30e072fb1a699177a628212a2b33406c7d019ace
-  data.tar.gz: 9ce87f41aa773aae74fa0a822e492263e95d7c4f63aac26eb77a8385351eaa6b
+  metadata.gz: a2cb129cd0e5a4f5f0f1daf6ed3cb26a4dab4d10cb56bbfcc419656c2797347a
+  data.tar.gz: df1fe343d28aeb72f8fe30dc53bdecd860e8bd44ae009a086c7ad502da77bfd8
 SHA512:
-  metadata.gz: 3a15a6742977c8f1a38f1eab5e5d9a5ef30d79cfd9db8ba630775f7629cd25486e00b63a2122a01281a303e396a0d5faefdcb4b399a65b4eaaf9aeb50ddac116
-  data.tar.gz: 4f24bee6532d2251e9051067582bc4bcd1e9ef685996ff34eff15416976774387731917f66482c62efc9d205c552fcd3aacb8b73f869005585fd66fd86b89d12
+  metadata.gz: 1449245c23bcc2c5f3c4266712c67b202e4e2c6724ee9f283bd81d76b2daedc4bc06ee524ed8d959d13f31062b393b5f7cfb7f46721888efb8d89bbd4d8a12b3
+  data.tar.gz: 649a20ee71c55d8486d8264b641974c3222baa477133d6924ba039f2ef24f9185d2b60b2f37f7d2ff498b87aaed09b78815feb3bbc52c92613eb810de2c59c2c

data/README.md

@@ -1,13 +1,16 @@
 # ActiveGenie 🧞‍♂️
-> The lodash for GenAI, stop reinventing the wheel
+> The Lodash for GenAI: Real Value + Consistent + Model-Agnostic
 
 [![Gem Version](https://badge.fury.io/rb/active_genie.svg?icon=si%3Arubygems)](https://badge.fury.io/rb/active_genie)
 [![Ruby](https://github.com/roriz/active_genie/actions/workflows/benchmark.yml/badge.svg)](https://github.com/roriz/active_genie/actions/workflows/benchmark.yml)
 
-ActiveGenie is a Ruby gem that provides valuable solutions powered by Generative AI (GenAI) models. Just like Lodash or ActiveStorage, ActiveGenie brings a set of Modules to reach real value fast and reliably.
-ActiveGenie is backed by a custom benchmarking system that ensures consistent quality and performance across different models and providers in every release.
+ActiveGenie is a developer-first library for GenAI workflows, designed to help you extract, compare, score, and rank with consistency and model-agnostic. Think of it as the Lodash for GenAI: built for real value, consistent results, and freedom from vendor lock-in. It solves the biggest pain in GenAI today: getting predictable, trustworthy answers across use cases, models, and providers.
 
-## Installation
+Behind the scenes, a custom benchmarking system keeps everything consistent across LLM vendors and versions, release after release.
+
+For full documentation, visit [activegenie.ai](https://activegenie.ai).
+
+# Installation
 
 1. Add to your Gemfile:
 ```ruby
@@ -32,9 +35,7 @@ ActiveGenie.configure do |config|
 end
 ```
 
-## Quick Start
-
-### Data Extractor
+## Quick start example
 
 Extract structured data from text using AI-powered analysis, handling informal language and complex expressions.
 
@@ -71,197 +72,9 @@ result = ActiveGenie::DataExtractor.call(
 #    }
 ```
 
-*Recommended model*: `gpt-4o-mini`
-
-Features:
-- Structured data extraction with type validation
-- Schema-based extraction with custom constraints
-- Informal text analysis (litotes, hedging)
-- Detailed explanations for extracted values
-
-See the [Data Extractor README](lib/active_genie/data_extractor/README.md) for informal text processing, advanced schemas, and detailed interface documentation.
-
-### Scoring
-Text evaluation system that provides detailed scoring and feedback using multiple expert reviewers. Get balanced scoring through AI-powered expert reviewers that automatically adapt to your content.
-
-```ruby
-text = "The code implements a binary search algorithm with O(log n) complexity"
-criteria = "Evaluate technical accuracy and clarity"
-
-result = ActiveGenie::Scoring.call(
-  text,
-  criteria,
-  config: { provider: :anthropic, model: 'claude-3-5-haiku-20241022' } # optional
-)
-# => {
-#      algorithm_expert_score: 95,
-#      algorithm_expert_reasoning: "Accurately describes binary search and its complexity",
-#      technical_writer_score: 90,
-#      technical_writer_reasoning: "Clear and concise explanation of the algorithm",
-#      final_score: 92.5
-#    }
-```
-
-*Recommended model*: `claude-3-5-haiku-20241022`
-
-Features:
-- Multi-reviewer evaluation with automatic expert selection
-- Detailed feedback with scoring reasoning
-- Customizable reviewer weights
-- Flexible evaluation criteria
-
-See the [Scoring README](lib/active_genie/scoring/README.md) for advanced usage, custom reviewers, and detailed interface documentation.
-
-### Battle
-AI-powered battle evaluation system that determines winners between two players based on specified criteria.
-
-```ruby
-require 'active_genie'
-
-player_a = "Implementation uses dependency injection for better testability"
-player_b = "Code has high test coverage but tightly coupled components"
-criteria = "Evaluate code quality and maintainability"
-
-result = ActiveGenie::Battle.call(
-  player_a,
-  player_b,
-  criteria,
-  config: { provider: :google, model: 'gemini-2.0-flash-lite' } # optional
-)
-# => {
-#      winner_player: "Implementation uses dependency injection for better testability",
-#      reasoning: "Player 1 implementation demonstrates better maintainability through dependency injection,
-#                 which allows for easier testing and component replacement. While Player 2 has good test coverage,
-#                 the tight coupling makes the code harder to maintain and modify.",
-#      what_could_be_changed_to_avoid_draw: "Focus on specific architectural patterns and design principles"
-#    }
-```
-
-*Recommended model*: `claude-3-5-haiku`
+## Documentation
 
-Features:
-- Multi-reviewer evaluation with automatic expert selection
-- Detailed feedback with scoring reasoning
-- Customizable reviewer weights
-- Flexible evaluation criteria
-
-See the [Battle README](lib/active_genie/battle/README.md) for advanced usage, custom reviewers, and detailed interface documentation.
-
-### Ranking
-The Ranking module provides competitive ranking through multi-stage evaluation:
-
-```ruby
-require 'active_genie'
-
-players = ['REST API', 'GraphQL API', 'SOAP API', 'gRPC API', 'Websocket API']
-criteria = "Best one to be used into a high changing environment"
-
-result = ActiveGenie::Ranking.call(
-  players,
-  criteria,
-  config: { provider: :google, model: 'gemini-2.0-flash-lite' } # optional
-)
-# => {
-#      winner_player: "gRPC API",
-#      reasoning: "gRPC API is the best one to be used into a high changing environment",
-#    }
-```
-
-*Recommended model*: `gemini-2.0-flash-lite`
-
-- **Multi-phase ranking system** combining expert scoring and ELO algorithms
-- **Automatic elimination** of inconsistent performers using statistical analysis
-- **Dynamic ranking adjustments** based on simulated pairwise battles, from bottom to top
-
-See the [Ranking README](lib/active_genie/ranking/README.md) for implementation details, configuration, and advanced ranking strategies.
-
-### Text Summarizer (Future)
-### Categorizer (Future)
-### Language detector (Future)
-### Translator (Future)
-### Sentiment analyzer (Future)
-
-## Benchmarking 🧪
-
-ActiveGenie includes a comprehensive benchmarking system to ensure consistent, high-quality outputs across different LLM models and providers.
-
-```ruby
-# Run all benchmarks
-bundle exec rake active_genie:benchmark
-
-# Run benchmarks for a specific module
-bundle exec rake active_genie:benchmark[data_extractor]
-```
-
-### Latest Results
-
-| Model | Overall Precision |
-|-------|-------------------|
-| claude-3-5-haiku-20241022 | 92.25% |
-| gemini-2.0-flash-lite | 84.25% |
-| gpt-4o-mini | 62.75% |
-| deepseek-chat | 57.25% |
-
-See the [Benchmark README](benchmark/README.md) for detailed results, methodology, and how to contribute to our test suite.
-
-## Basic Configuration
-
-| Config | Type | Description | Default |
-|--------|------|-------------|---------|
-| `llm.provider` | Symbol | LLM provider (openai, anthropic, etc) | `nil` |
-| `llm.model` | String | Model to use | `nil` |
-| `llm.temperature` | Float | Temperature to use | `0` |
-| `llm.max_tokens` | Integer | Maximum tokens to use | `4096` |
-| `llm.max_retries` | Integer | Maximum retry attempts | `3` |
-| `log.output` | Proc | Log output | `->(log) { $stdout.puts log }` |
-| `ranking.score_variation_threshold` | Integer | Score variation threshold | `30` |
-
-> **Note:** Each module can append its own set of configuration, see the individual module documentation for details.
-
-Read all [configuration](lib/active_genie/config/README.md) for all available options.
-
-## How to create a new provider
-
-ActiveGenie supports adding custom providers to integrate with different LLM services. To create a new provider:
-
-1. Create a configuration class for your provider in `lib/active_genie/configuration/providers/`:
-2. Register your client
-
-```ruby
-class InternalCompanyApi
-  # @param messages [Array<Hash>] A list of messages representing the conversation history.
-  #   Each hash should have :role ('user', 'assistant', or 'system') and :content (String).
-  # @param function [Hash] A JSON schema definition describing the desired output format.
-  # @return [Hash, nil] The parsed JSON object matching the schema, or nil if parsing fails or content is empty.
-  def function_calling(messages, function)
-    # ...
-  end
-end
-
-ActiveGenie.configure do |config|
-  config.llm.client = InternalCompanyApi
-end
-# or
-ActiveGenie::Battle.call('player_a', 'player_b', 'criteria', { client: InternalCompanyApi })
-```
-
-## Observability
-Fundamental to managing any production system, observability is crucial for GenAI features. At a minimum, track these key metrics:
-
-- Usage Rate (e.g., uses_per_minute): Detect anomalies like sudden traffic spikes (potential DDoS) or drops (feature outage or declining usage).
-- Failure/Retry Rate (e.g., retry_count, fail_count): Monitor the frequency of errors. Exceeding a defined threshold should trigger downtime or degradation alerts.
-- Token Consumption (e.g., tokens_used): Track usage to monitor costs. Set alerts if tokens_used * price_per_token exceeds budget thresholds.
-
-```ruby
-ActiveGenie.configure do |config|
-  config.log.add_observer(scope: { code: :llm_usage }) do |log|
-    puts "LLM Usage: #{log[:model]} - #{log[:total_tokens]} tokens"
-  end
-  config.log.add_observer(scope: { code: :retry_attempt }) do |log|
-    puts "Retry Attempt: #{log[:attempt]} of #{log[:max_retries]}"
-  end
-end
-```
+For full documentation, visit [activegenie.ai](https://activegenie.ai).
 
 ## Contributing
 

data/VERSION

@@ -1 +1 @@
-0.26.6
+0.28.2

data/lib/active_genie/battle/fight.json

@@ -0,0 +1,61 @@
+{
+  "name": "fight_evaluation",
+  "description": "Evaluate a fight between player_a and player_b using predefined criteria and identify the winner.",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "player_a_introduction": {
+        "type": "string",
+        "description": "player_a introduces their name and fighting style. Max of 100 words."
+      },
+      "player_b_introduction": {
+        "type": "string",
+        "description": "player_b introduces their name and fighting style. Max of 100 words."
+      },
+      "player_a_turn_1": {
+        "type": "string",
+        "description": "player_a makes their first turn. Max of 100 words."
+      },
+      "player_b_turn_1": {
+        "type": "string",
+        "description": "player_b makes their first turn. Max of 100 words."
+      },
+      "player_a_turn_2": {
+        "type": "string",
+        "description": "player_a makes their second turn. Max of 100 words."
+      },
+      "player_b_turn_2": {
+        "type": "string",
+        "description": "player_b makes their second turn. Max of 100 words."
+      },
+      "player_a_turn_3": {
+        "type": "string",
+        "description": "player_a makes their third turn. Max of 100 words."
+      },
+      "player_b_turn_3": {
+        "type": "string",
+        "description": "player_b makes their third turn. Max of 100 words."
+      },
+      "player_a_turn_4": {
+        "type": "string",
+        "description": "player_a makes their fourth turn. Max of 100 words."
+      },
+      "player_b_turn_4": {
+        "type": "string",
+        "description": "player_b makes their fourth turn. Max of 100 words."
+      },
+      "impartial_judge_winner_reasoning": {
+        "type": "string",
+        "description": "The detailed reasoning about why the impartial judge chose the winner. Max of 100 words."
+      },
+      "impartial_judge_winner": {
+        "type": "string",
+        "description": "Who is the winner based on the impartial judge reasoning?",
+        "enum": ["player_a", "player_b"]
+      }
+    },
+    "required": ["player_a_introduction", "player_b_introduction", "player_a_turn_1", "player_b_turn_1",
+                 "player_a_turn_2", "player_b_turn_2", "player_a_turn_3", "player_b_turn_3", "player_a_turn_4",
+                 "player_b_turn_4", "impartial_judge_winner_reasoning", "impartial_judge_winner"]
+  }
+}

data/lib/active_genie/battle/fight.prompt.md

@@ -0,0 +1,41 @@
+Create a dynamic, back-and-forth verbal match between two fighters, given their names and preferred fighting styles. In this match, fighters do not physically battle, instead, they engage in a spoken confrontation, each describing and boasting about their fighting style, how their techniques would outmaneuver, counter, or overwhelm the other's approach. Ensure that each verbal exchange details:
+- The technique or strategy the speaker would use.
+- How that move is superior to the opponent’s last stated tactic.
+- How the opponent might respond, and what reply the speaker would have.
+
+Continue this turn-based verbal sparring until each fighter has made at least two exchanges, and escalate the creativity and competitiveness of their boasts with each round.
+
+Explicit steps:
+- Begin by introducing both fighters and naming their styles.
+- Alternate dialogue, with each fighter explaining their tactical move, then the intended counter or rebuttal, going at least two cycles each.
+- Ensure reasoning (the logic or explanation behind each technique and counter) always precedes the conclusion or actual "move" or taunt.
+- Close with a final statement or taunt from each fighter, maintaining the competitive tone.
+- Make the dialogue lively and imaginative, using language consistent with fighters boasting or challenging each other.
+
+Output Format:
+- Structure as a script, with each turn labeled by the fighter’s name.
+- Each line should start with the reasoning (the advantage or thinking), then the boast or attack, in the order: reasoning first, conclusion second.
+- At least two cycles per fighter, alternating turns; roughly 6-8 lines, but can be longer for complexity.
+- No code blocks, use markdown for formatting.
+
+Example:
+
+Example Input:
+Fighter One: Master Crane, Style: Crane Kung Fu
+Fighter Two: Iron Ox, Style: Ox Bull Charge
+
+Example Output:
+Master Crane: My Crane Kung Fu relies on lightness and precision, striking where your heavy blows simply can't reach. Your Ox Bull Charge is powerful, but too direct, I'd dance aside and tap your pressure points before you even turn.
+Iron Ox: While speed is impressive, strength dominates in a real fight. My Ox Bull Charge would absorb your nimble attacks, and my sheer mass pins you before you could even flutter away!
+Master Crane: Adaptability ensures survival. As you lumber forward, I use your momentum to redirect you, your own strength becomes your undoing as you stumble into my calculated traps.
+Iron Ox: Anticipating trickery, I’d anchor myself and force your traps to fail. Your frailty means that, once caught, no escape, one bear hug from me, and there’s no dancing away.
+Master Crane: Patience and timing can unravel even the strongest grip. Just as you squeeze, a swift strike to your nerve centers will loosen your hold before you know it.
+Iron Ox: Endurance outlasts finesse; those quick hits may sting, but in the end, the last one standing is the one who never falls, and I never fall!
+
+(Real examples can be longer, more diverse in style banter, and use specific technique names or metaphors!)
+
+Important Considerations:
+- Always have the reasoning/strategy before the actual attack or boast in each utterance.
+- Maintain the turn order and competitive dialogue style.
+
+*Reminder: The main objective is to script an imaginative, turn-based verbal contest between two stylized fighters, with detailed reasoning and taunts about their style advantages, as instructed above.*

data/lib/active_genie/battle/fight.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../clients/unified_client'
+require_relative 'generalist'
+
+module ActiveGenie
+  module Battle
+    # The Fight class are battle specialized in a fight between two fighters, like martial arts, heroes, characters.
+    # The fight evaluation process simulate a fight using words, techniques, strategies, and reasoning.
+    #
+    # @example Fight usage with two fighters and criteria
+    #   Fight.call("Naruto", "Sasuke", "How can win without using jutsu?")
+    #
+    class Fight < Generalist
+      # @return [BattleResponse] The evaluation result containing the winner and reasoning
+      def call
+        messages = [
+          {  role: 'system', content: PROMPT },
+          {  role: 'user', content: "criteria: #{@criteria}" },
+          {  role: 'user', content: "player_a: #{@player_a}" },
+          {  role: 'user', content: "player_b: #{@player_b}" }
+        ]
+
+        response = ::ActiveGenie::Clients::UnifiedClient.function_calling(
+          messages,
+          FUNCTION,
+          config: @config
+        )
+
+        response_formatted(response)
+      end
+
+      PROMPT = File.read(File.join(__dir__, 'fight.prompt.md'))
+      FUNCTION = JSON.parse(File.read(File.join(__dir__, 'fight.json')), symbolize_names: true)
+    end
+  end
+end

data/lib/active_genie/battle/generalist.rb

@@ -15,6 +15,8 @@ module ActiveGenie
     #   Generalist.call("Player A content", "Player B content", "Evaluate keyword usage and pattern matching")
     #
     class Generalist
+      BattleResponse = Struct.new(:winner, :loser, :reasoning, :raw, keyword_init: true)
+
       def self.call(...)
         new(...).call
       end
@@ -23,7 +25,7 @@ module ActiveGenie
       # @param player_b [String] The content or submission from the second player
       # @param criteria [String] The evaluation criteria or rules to assess against
       # @param config [Hash] Additional configuration options that modify the battle evaluation behavior
-      # @return [Hash] The evaluation result containing the winner and reasoning
+      # @return [BattleResponse] The evaluation result containing the winner and reasoning
       #   @return [String] :winner The winner, either player_a or player_b
       #   @return [String] :reasoning Detailed explanation of why the winner was chosen
       #   @return [String] :what_could_be_changed_to_avoid_draw A suggestion on how to avoid a draw
@@ -34,6 +36,7 @@ module ActiveGenie
         @config = ActiveGenie.configuration.merge(config)
       end
 
+      # @return [BattleResponse] The evaluation result containing the winner and reasoning
       def call
         messages = [
           {  role: 'system', content: PROMPT },
@@ -48,31 +51,35 @@ module ActiveGenie
           config: @config
         )
 
-        @config.logger.call({
-                              code: :battle,
-                              player_a: @player_a[0..30],
-                              player_b: @player_b[0..30],
-                              criteria: @criteria[0..30],
-                              winner: response['impartial_judge_winner'],
-                              reasoning: response['impartial_judge_winner_reasoning']
-                            })
-
         response_formatted(response)
       end
 
-      PROMPT = File.read(File.join(__dir__, 'generalist.md'))
+      PROMPT = File.read(File.join(__dir__, 'generalist.prompt.md'))
       FUNCTION = JSON.parse(File.read(File.join(__dir__, 'generalist.json')), symbolize_names: true)
 
       private
 
       def response_formatted(response)
-        winner = response['impartial_judge_winner']
-        loser = case winner
-                when 'player_a' then 'player_b'
-                when 'player_b' then 'player_a'
-                end
+        winner, loser = case response['impartial_judge_winner']
+                        when 'player_a' then [@player_a, @player_b]
+                        when 'player_b' then [@player_b, @player_a]
+                        end
+        reasoning = response['impartial_judge_winner_reasoning']
+
+        battle_response = BattleResponse.new(winner:, loser:, reasoning:, raw: response)
+        log_battle(battle_response)
 
-        { 'winner' => winner, 'loser' => loser, 'reasoning' => response['impartial_judge_winner_reasoning'] }
+        battle_response
+      end
+
+      def log_battle(battle_response)
+        @config.logger.call(
+          code: :battle,
+          player_a: @player_a[0..30],
+          player_b: @player_b[0..30],
+          criteria: @criteria[0..30],
+          **battle_response.to_h
+        )
       end
     end
   end

data/lib/active_genie/battle.rb

@@ -1,18 +1,27 @@
 # frozen_string_literal: true
 
 require_relative 'battle/generalist'
+require_relative 'battle/fight'
 
 module ActiveGenie
   # See the [Battle README](lib/active_genie/battle/README.md) for more information.
   module Battle
     module_function
 
+    def generalist(...)
+      Generalist.call(...)
+    end
+
     def call(...)
       Generalist.call(...)
     end
 
-    def generalist(...)
+    def compare(...)
       Generalist.call(...)
     end
+
+    def fight(...)
+      Fight.call(...)
+    end
   end
 end

data/lib/active_genie/data_extractor/generalist.rb

@@ -119,7 +119,7 @@ module ActiveGenie
       end
 
       def prompt
-        File.read(File.join(__dir__, 'generalist.md'))
+        File.read(File.join(__dir__, 'generalist.prompt.md'))
       end
     end
   end

data/lib/active_genie/scoring/generalist.rb

@@ -64,7 +64,7 @@ module ActiveGenie
         result
       end
 
-      PROMPT = File.read(File.join(__dir__, 'generalist.md'))
+      PROMPT = File.read(File.join(__dir__, 'generalist.prompt.md'))
 
       private
 

metadata

@@ -1,19 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: active_genie
 version: !ruby/object:Gem::Version
-  version: 0.26.6
+  version: 0.28.2
 platform: ruby
 authors:
 - Radamés Roriz
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-09 00:00:00.000000000 Z
+date: 2025-07-12 00:00:00.000000000 Z
 dependencies: []
 description: |
-  The lodash for GenAI, stop reinventing the wheel
-
-  ActiveGenie is a Ruby gem that provides valuable solutions using GenAI. Just like Lodash or ActiveStorage, ActiveGenie brings a set of Modules to reach real value fast and reliably. Backed by a custom benchmarking system that ensures consistent quality and performance across different models and providers in every release.
+  ActiveGenie is a Ruby gem that helps developers build reliable, future-proof GenAI features without worrying about changing models, prompts, or providers. Like Lodash for GenAI, it offers simple, reusable modules for tasks like data extraction, scoring, and ranking, so you can focus on your app’s logic, not the shifting AI landscape.
+  Behind the scenes, a custom benchmarking system keeps everything consistent across LLM vendors and versions, release after release.
 email:
 - radames@roriz.dev
 executables: []
@@ -25,9 +24,11 @@ files:
 - VERSION
 - lib/active_genie.rb
 - lib/active_genie/battle.rb
-- lib/active_genie/battle/README.md
+- lib/active_genie/battle/fight.json
+- lib/active_genie/battle/fight.prompt.md
+- lib/active_genie/battle/fight.rb
 - lib/active_genie/battle/generalist.json
-- lib/active_genie/battle/generalist.md
+- lib/active_genie/battle/generalist.prompt.md
 - lib/active_genie/battle/generalist.rb
 - lib/active_genie/clients/providers/anthropic_client.rb
 - lib/active_genie/clients/providers/base_client.rb
@@ -35,7 +36,6 @@ files:
 - lib/active_genie/clients/providers/google_client.rb
 - lib/active_genie/clients/providers/openai_client.rb
 - lib/active_genie/clients/unified_client.rb
-- lib/active_genie/config/README.md
 - lib/active_genie/config/battle_config.rb
 - lib/active_genie/config/data_extractor_config.rb
 - lib/active_genie/config/llm_config.rb
@@ -50,17 +50,15 @@ files:
 - lib/active_genie/config/scoring_config.rb
 - lib/active_genie/configuration.rb
 - lib/active_genie/data_extractor.rb
-- lib/active_genie/data_extractor/README.md
 - lib/active_genie/data_extractor/from_informal.json
 - lib/active_genie/data_extractor/from_informal.rb
 - lib/active_genie/data_extractor/generalist.json
-- lib/active_genie/data_extractor/generalist.md
+- lib/active_genie/data_extractor/generalist.prompt.md
 - lib/active_genie/data_extractor/generalist.rb
 - lib/active_genie/errors/invalid_log_output_error.rb
 - lib/active_genie/errors/invalid_provider_error.rb
 - lib/active_genie/logger.rb
 - lib/active_genie/ranking.rb
-- lib/active_genie/ranking/README.md
 - lib/active_genie/ranking/elo_round.rb
 - lib/active_genie/ranking/free_for_all.rb
 - lib/active_genie/ranking/player.rb
@@ -68,9 +66,8 @@ files:
 - lib/active_genie/ranking/ranking.rb
 - lib/active_genie/ranking/ranking_scoring.rb
 - lib/active_genie/scoring.rb
-- lib/active_genie/scoring/README.md
 - lib/active_genie/scoring/generalist.json
-- lib/active_genie/scoring/generalist.md
+- lib/active_genie/scoring/generalist.prompt.md
 - lib/active_genie/scoring/generalist.rb
 - lib/active_genie/scoring/recommended_reviewers.rb
 - lib/tasks/benchmark.rake
@@ -103,5 +100,5 @@ requirements: []
 rubygems_version: 3.4.20
 signing_key:
 specification_version: 4
-summary: Transform your Ruby application with powerful, production-ready GenAI features
+summary: 'The Lodash for GenAI: Real Value + Consistent + Model-Agnostic'
 test_files: []

data/lib/active_genie/battle/README.md

@@ -1,39 +0,0 @@
-# Battle
-AI-powered battle evaluation system that determines winners between two players based on specified criteria.
-
-## Features
-- Content comparison - Evaluate submissions from two players against defined criteria
-- Objective analysis - AI-powered assessment of how well each player meets requirements
-- Detailed reasoning - Comprehensive explanation of why a winner was chosen
-- Draw avoidance - Suggestions on how to modify content to avoid draws
-- Flexible input - Support for both string content and structured data with content field
-
-## Basic Usage
-Evaluate a battle between two players with simple text content:
-
-```ruby
-player_a = "Implementation uses dependency injection for better testability"
-player_b = "Code has high test coverage but tightly coupled components"
-criteria = "Evaluate code quality and maintainability"
-
-result = ActiveGenie::Battle.call(player_a, player_b, criteria)
-# => {
-#      winner_player: "Implementation uses dependency injection for better testability",
-#      reasoning: "Player A's implementation demonstrates better maintainability through dependency injection,
-#                 which allows for easier testing and component replacement. While Player B has good test coverage,
-#                 the tight coupling makes the code harder to maintain and modify.",
-#      what_could_be_changed_to_avoid_draw: "Focus on specific architectural patterns and design principles"
-#    }
-```
-
-## Interface
-### .call(player_a, player_b, criteria, config: {})
-- `player_a` [String, Hash] - The content or submission from the first player
-- `player_b` [String, Hash] - The content or submission from the second player
-- `criteria` [String] - The evaluation criteria or rules to assess against
-- `config` [Hash] - Additional configuration config that modify the battle evaluation behavior
-
-Returns a Hash containing:
-- `winner_player` [String, Hash] - The winning player's content (either player_a or player_b)
-- `reasoning` [String] - Detailed explanation of why the winner was chosen
-- `what_could_be_changed_to_avoid_draw` [String] - A suggestion on how to avoid a draw

data/lib/active_genie/config/README.md

@@ -1,235 +0,0 @@
-# ActiveGenie Configuration
-
-ActiveGenie provides a flexible configuration system that can be customized to suit your needs. This document details all available configuration options.
-
-## Initial Configuration
-
-To configure ActiveGenie, use the `ActiveGenie.configure` block in your application's initialization:
-
-```ruby
-ActiveGenie.configure do |config|
-  # Provider configurations
-  config.providers.openai.api_key = ENV['OPENAI_API_KEY']
-
-  # Log configurations
-  config.log.file_path = 'log/custom_genie.log'
-  config.log.fine_tune_file_path = 'log/fine_tune_genie.log'
-
-  # Other configurations can be added here
-end
-```
-
-## Configuration Sections
-
-### 1. Log Configuration (`config.log`)
-
-The log configuration controls how ActiveGenie handles logging of its operations.
-
-#### Available Settings:
-
-| Setting | Type | Default | Description |
-|---------|------|---------|-------------|
-| `file_path` | String | `'log/active_genie.log'` | Path to the main log file where all logs will be written. |
-| `fine_tune_file_path` | String | `'log/active_genie_fine_tune.log'` | Path to the fine-tuning specific log file. |
-| `output` | Proc | `->(log) { $stdout.puts log }` | Custom output handler for logs. Must respond to `call`. |
-| `additional_context` | Hash | `{}` | Additional context to be added to each log entry. |
-
-#### Methods:
-
-- `add_observer(observers: [], scope: {}, &block)`
-  - Adds log observers that will be notified of log events.
-  - `observers`: An array of callable objects or a single callable object.
-  - `scope`: A hash to filter which logs the observer receives.
-  - `block`: A block that will be called for matching logs.
-
-- `remove_observer(observers)`
-  - Removes the specified observers.
-
-#### Example:
-
-```ruby
-ActiveGenie.configure do |config|
-  config.log.file_path = 'log/my_app/genie.log'
-  config.log.fine_tune_file_path = 'log/my_app/fine_tune.log'
-
-  # Add a custom output handler
-  config.log.output = ->(log) { MyLogger.info(log) }
-
-  # Add an observer for specific log events
-  config.log.add_observer(scope: { event: :api_call }) do |log|
-    StatsD.increment("genie.api_calls")
-  end
-end
-```
-
-### 2. LLM Configuration (`config.llm`)
-
-The LLM configuration is used to define settings for interacting with Large Language Models.
-
-#### Available Settings:
-
-| Setting         | Type                | Default                      | Description                                                                                                |
-|-----------------|---------------------|------------------------------|------------------------------------------------------------------------------------------------------------|
-| `model`         | String / nil        | `nil`                        | The specific LLM model to use (e.g., 'gpt-4', 'claude-2').                                                 |
-| `provider`      | Symbol / nil        | `nil`                        | The LLM provider (e.g., `:openai`, `:anthropic`). Set as a string, stored as a symbol.                       |
-| `client`        | Object / nil        | `nil`                        | A pre-configured client instance for the LLM provider. If set, other settings might be ignored.            |
-| `temperature`   | Numeric             | `0`                          | Controls randomness. Higher values (e.g., 0.8) = more random, lower (e.g., 0.2) = more deterministic.        |
-| `max_tokens`    | Integer             | `4096`                       | Maximum number of tokens to generate in the LLM response.                                                  |
-| `max_retries`   | Integer / nil       | `nil`                        | Maximum number of times to retry a failed API call to the LLM.                                             |
-| `retry_delay`   | Numeric / nil       | `nil`                        | Delay (in seconds) between retries for failed API calls.                                                   |
-| `model_tier`    | Enum [lower_tier, middle_tier, higher_tier]              | `'lower_tier'`               | Specifies the model tier, potentially affecting cost/performance. Will be used if `model` is not set.       |
-| `read_timeout`  | Numeric / nil       | `nil`                        | Timeout (in seconds) for reading data from the LLM API.                                                    |
-| `open_timeout`  | Numeric / nil       | `nil`                        | Timeout (in seconds) for establishing a connection to the LLM API.                                         |
-
-#### Example:
-
-```ruby
-ActiveGenie.configure do |config|
-  config.llm.provider = :openai
-  config.llm.model = 'gpt-999'
-  config.llm.temperature = 0.1
-  config.llm.max_tokens = 8000
-  config.llm.max_retries = 1
-  config.llm.retry_delay = 5 # seconds
-  config.llm.model_tier = 'higher_tier' # If model is not set, will use the model tier to select a model
-end
-```
-
-### 4. Providers Configuration (`config.providers`)
-
-The Providers configuration (`config.providers`) manages settings for various Large Language Model (LLM) providers. It allows you to configure multiple providers, set a default, and access individual provider settings. Active Genie automatically loads configurations for supported providers (OpenAI, Anthropic, DeepSeek, Google).
-
-#### Main Provider Settings:
-
-| Setting   | Type                | Default                        | Description                                                                 |
-|-----------|---------------------|--------------------------------|-----------------------------------------------------------------------------|
-| `default` | String / Symbol     | First validly configured provider (often `:openai` if its API key is set) | The name of the default LLM provider to use (e.g., `:openai`, `:anthropic`). You can set this to your preferred provider. |
-
-#### Methods for `config.providers`:
-
--   `add(provider_classes)`
-    -   Adds one or more custom provider configuration classes. `provider_classes` can be a single class or an array of classes. (Typically not needed for built-in providers).
--   `remove(provider_classes)`
-    -   Removes one or more provider configurations based on their classes.
-
-#### Example for Main Provider Settings:
-
-```ruby
-ActiveGenie.configure do |config|
-  # Set the default provider to use if not specifying one explicitly in operations
-  config.providers.default = :anthropic
-
-  # Configure individual providers (API keys are often set via ENV variables)
-  config.providers.openai.api_key = ENV['OPENAI_API_KEY']
-  config.providers.anthropic.api_key = ENV['ANTHROPIC_API_KEY']
-  # config.providers.deepseek.api_key = ENV['DEEPSEEK_API_KEY']
-  # config.providers.google.api_key = ENV['GEMINI_API_KEY']
-end
-```
-
-#### Individual Provider Configurations:
-
-The following subsections detail the configurations for each supported LLM provider. Each provider configuration (e.g., `config.providers.openai`) allows setting an `api_key`, `api_url`, and specific model names for `lower_tier_model`, `middle_tier_model`, and `higher_tier_model`.
-
-##### a. OpenAI (`config.providers.openai`)
-
-Internal Name: `:openai`
-
-| Setting             | Type   | Default                               | Description                                                                 |
-|---------------------|--------|---------------------------------------|-----------------------------------------------------------------------------|
-| `api_key`           | String | `ENV['OPENAI_API_KEY']`               | Your OpenAI API key.                                                        |
-| `api_url`           | String | `'https://api.openai.com/v1'`         | Base URL for the OpenAI API.                                                |
-| `lower_tier_model`  | String | `'gpt-4.1-mini'`                      | Model for lower-tier usage (cost-effective, faster).                        |
-| `middle_tier_model` | String | `'gpt-4.1'`                           | Model for middle-tier usage (balanced performance).                         |
-| `higher_tier_model` | String | `'o3-mini'`                           | Model for higher-tier usage (most capable).                                 |
-
-##### b. Anthropic (`config.providers.anthropic`)
-
-Internal Name: `:anthropic`
-
-| Setting             | Type   | Default                                  | Description                                                                 |
-|---------------------|--------|------------------------------------------|-----------------------------------------------------------------------------|
-| `api_key`           | String | `ENV['ANTHROPIC_API_KEY']`               | Your Anthropic API key.                                                     |
-| `api_url`           | String | `'https://api.anthropic.com'`            | Base URL for the Anthropic API.                                             |
-| `anthropic_version` | String | `'2023-06-01'`                           | The API version for Anthropic.                                              |
-| `lower_tier_model`  | String | `'claude-3-5-haiku-20241022'`            | Model for lower-tier usage.                                                 |
-| `middle_tier_model` | String | `'claude-3-7-sonnet-20250219'`           | Model for middle-tier usage.                                                |
-| `higher_tier_model` | String | `'claude-3-opus-20240229'`               | Model for higher-tier usage.                                                |
-
-##### c. DeepSeek (`config.providers.deepseek`)
-
-Internal Name: `:deepseek`
-
-| Setting             | Type   | Default                               | Description                                                                 |
-|---------------------|--------|---------------------------------------|-----------------------------------------------------------------------------|
-| `api_key`           | String | `ENV['DEEPSEEK_API_KEY']`             | Your DeepSeek API key.                                                      |
-| `api_url`           | String | `'https://api.deepseek.com/v1'`       | Base URL for the DeepSeek API.                                              |
-| `lower_tier_model`  | String | `'deepseek-chat'`                     | Model for lower-tier usage.                                                 |
-| `middle_tier_model` | String | `'deepseek-chat'`                     | Model for middle-tier usage.                                                |
-| `higher_tier_model` | String | `'deepseek-reasoner'`                 | Model for higher-tier usage.                                                |
-
-##### d. Google (`config.providers.google`)
-
-Internal Name: `:google`
-
-| Setting             | Type   | Default                                                       | Description                                                                 |
-|---------------------|--------|---------------------------------------------------------------|-----------------------------------------------------------------------------|
-| `api_key`           | String | `ENV['GENERATIVE_LANGUAGE_GOOGLE_API_KEY']` or `ENV['GEMINI_API_KEY']` | Your Google API key for Gemini.                                           |
-| `api_url`           | String | `'https://generativelanguage.googleapis.com'`                 | Base URL for the Google Generative Language API.                            |
-| `lower_tier_model`  | String | `'gemini-2.0-flash-lite'`                                     | Model for lower-tier usage.                                                 |
-| `middle_tier_model` | String | `'gemini-2.0-flash'`                                          | Model for middle-tier usage.                                                |
-| `higher_tier_model` | String | `'gemini-2.5-pro-experimental'`                               | Model for higher-tier usage.                                                |
-
-#### Example for Overriding Individual Provider Settings:
-
-```ruby
-ActiveGenie.configure do |config|
-  config.providers.openai.api_key = 'sk-yourOpenAiKey...'
-  config.providers.openai.middle_tier_model = 'gpt-4o' # Override default middle tier for OpenAI
-
-  config.providers.anthropic.api_key = 'sk-ant-yourAnthropicKey...'
-  config.providers.anthropic.anthropic_version = '2024-02-15' # Override Anthropic API version
-
-  config.providers.google.higher_tier_model = 'gemini-1.5-pro-latest' # Use a specific Google model
-end
-```
-
-### 5. Ranking Configuration (`config.ranking`)
-
-The Ranking configuration (`config.ranking`) deals with settings related to how results or items are ranked.
-
-#### Available Settings:
-
-| Setting                     | Type    | Default | Description                                                                                                |
-|-----------------------------|---------|---------|------------------------------------------------------------------------------------------------------------|
-| `score_variation_threshold` | Integer | `30`    | A threshold (percentage) used to determine significant variations in scores when ranking or comparing items. |
-
-#### Example:
-
-```ruby
-ActiveGenie.configure do |config|
-  config.ranking.score_variation_threshold = 25 # Set to 25%
-end
-```
-
-### 6. Data Extractor Configuration (`config.data_extractor`)
-
-The Data Extractor configuration (`config.data_extractor`) provides settings for how data is extracted and processed, likely from text or other sources using LLMs.
-
-#### Available Settings:
-
-| Setting            | Type    | Default | Description                                                                                             |
-|--------------------|---------|---------|---------------------------------------------------------------------------------------------------------|
-| `with_explanation` | Boolean | `true`  | Whether the data extraction process should also attempt to provide an explanation for the extracted data. |
-| `min_accuracy`     | Integer | `70`    | The minimum accuracy (percentage) required for extracted data to be considered valid or useful.         |
-| `verbose`          | Boolean | `false` | If true, enables more detailed logging or output from the data extraction process.                      |
-
-#### Example:
-
-```ruby
-ActiveGenie.configure do |config|
-  config.data_extractor.with_explanation = false
-  config.data_extractor.min_accuracy = 85
-  config.data_extractor.verbose = true
-end
-```

data/lib/active_genie/data_extractor/README.md

@@ -1,131 +0,0 @@
-# Data Extractor
-Extract structured data from text using AI-powered analysis, handling informal language and complex expressions.
-
-## ✨ Features
-- Structured data extraction - Extract typed data from unstructured text using predefined schemas
-- Informal text analysis - Identifies and handles informal language patterns, including litotes
-- Explanation tracking - Provides reasoning for each extracted data point
-
-## Basic Usage
-
-Extract structured data from text using predefined schemas:
-
-```ruby
-text = "John Doe is 25 years old"
-schema = {
-  name: { type: 'string', description: 'Full name of the person' },
-  age: { type: 'integer', description: 'Age in years' }
-}
-result = ActiveGenie::DataExtractor.call(text, schema)
-# => {
-#      name: "John Doe",
-#      name_explanation: "Found directly in text",
-#      age: 25,
-#      age_explanation: "Explicitly stated as 25 years old"
-#    }
-
-product = "Nike Air Max 90 - Size 42 - $199.99"
-schema = {
-  brand: {
-    type: 'string',
-    enum: ["Nike", "Adidas", "Puma"]
-  },
-  price: {
-    type: 'number',
-    minimum: 0
-  },
-  currency: {
-    type: 'string',
-    enum: ["USD", "EUR"]
-  },
-  size: {
-    type: 'integer',
-    minimum: 35,
-    maximum: 46
-  }
-}
-
-result = ActiveGenie::DataExtractor.call(product, schema)
-# => {
-#      brand: "Nike",
-#      brand_explanation: "Brand name found at start of text",
-#      price: 199.99,
-#      price_explanation: "Price found in USD format at end",
-#      size: 42,
-#      size_explanation: "Size explicitly stated in the middle",
-#      currency: "USD",
-#      currency_explanation: "Derived from $ symbol"
-#    }
-```
-
-## Informal Text Processing
-
-The `from_informal` method extends the basic extraction by analyzing rhetorical devices and informal language patterns like:
-
-- Litotes ("not bad", "isn't terrible")
-- Affirmative expressions ("sure", "no problem")
-- Negative expressions ("nah", "not really")
-
-### Example
-
-```ruby
-text = "The weather isn't bad today"
-schema = {
-  mood: { type: 'string', description: 'The mood of the message' }
-}
-
-result = ActiveGenie::DataExtractor.from_informal(text, schema)
-# => {
-#      mood: "positive",
-#      mood_explanation: "Speaker views weather favorably",
-#      message_litote: true,
-#      litote_rephrased: "The weather is good today"
-#    }
-```
-
-### Usage Notes
-- Best suited for processing conversational user inputs
-- Automatically detects and interprets litotes
-- Provides rephrased positive statements for litotes
-- May require more processing time due to rhetorical analysis
-- Accuracy depends on context clarity
-
-⚠️ Performance Impact: This method performs additional rhetorical analysis, which can increase processing time.
-
-## Interface
-
-### `.call(text, data_to_extract, config = {})`
-Extracts structured data from text based on a predefined schema.
-
-#### Parameters
-| Name | Type | Description | Required | Example |
-| --- | --- | --- | --- | --- |
-| `text` | `String` | The text to analyze and extract data from | Yes | "John Doe is 25 years old" |
-| `data_to_extract` | `Hash` | Schema defining the data structure to extract | Yes | `{ name: { type: 'string' } }` |
-| `config` | `Hash` | Additional extraction configuration | No | `{ model: "gpt-4" }` |
-
-#### config
-| Name | Type | Description |
-| --- | --- | --- |
-| `model` | `String` | The model to use for the extraction |
-| `api_key` | `String` | The API key to use for the extraction |
-
-#### Returns
-`Hash` containing:
-- Extracted values matching the schema structure
-- Explanation field for each extracted value
-- Additional analysis fields when using `from_informal`
-
-### `.from_informal(text, data_to_extract, config = {})`
-Extends  extraction with rhetorical analysis, particularly for litotes.
-
-#### Additional Return Fields
-| Name | Type | Description |
-| --- | --- | --- |
-| `message_litote` | `Boolean` | Whether the text contains a litote |
-| `litote_rephrased` | `String` | Positive rephrasing of any detected litote |
-
-⚠️ Performance Considerations
-- Both methods may require multiple AI model calls
-- Informal processing requires additional rhetorical analysis
-- Consider background processing for production use

data/lib/active_genie/ranking/README.md

@@ -1,73 +0,0 @@
-# Ranking
-
-The `ActiveGenie::Ranking` module organizes players based on scores derived from textual evaluations and then ranks them using a multi-stage process. It leverages the scoring system from the `ActiveGenie::Scoring` module to assign initial scores, and then applies advanced ranking methods to produce a competitive ranking.
-
-## Overview
-
-The ranking system performs the following steps:
-
-1. **Initial Scoring**: Each player’s textual content is evaluated using `ActiveGenie::Scoring`. This produces a `score` based on multiple expert reviews.
-
-2. **Elimination of Poor Performers**: Players whose scores show a high coefficient of variation (indicating inconsistency) are progressively eliminated. This ensures that only competitive candidates continue in the ranking process.
-
-3. **ELO Ranking**: If there are more than 10 eligible players, an ELO-based ranking is applied. Battles between players are simulated via `ActiveGenie::Battle`, and scores are updated using an ELO algorithm tailored to the ranking.
-
-4. **Free for all Matches**: Finally, the remaining players engage in head-to-head matches where each unique pair competes. Match outcomes (wins, losses, draws) are recorded to finalize the rankings.
-
-## Components
-
-- **ranking**: Orchestrates the entire ranking process. Initializes player scores, eliminates outliers, and coordinates ranking rounds.
-
-- **EloRanking**: Applies an ELO-based system to rank players through simulated battles. It updates players’ ELO scores based on match outcomes and predefined rules (including penalties for losses).
-
-- **Free for all**: Conducts complete pairwise matches among eligible players to record win/loss/draw statistics and refine the final standings.
-
-## Usage
-
-Call the ranking using:
-
-```ruby
-result = ActiveGenie::Ranking.call(players, criteria, config: {})
-```
-
-- `players`: A collection of player instances, each containing textual content to be scored.
-- `criteria`: A string defining the evaluation criteria used by the scoring system.
-- `config`: A hash of additional parameters for customization (e.g., model, api_key).
-
-The method processes the players through scoring, elimination, and ranking phases, then returns a hash containing the player statistics and rankings.
-
-## Possible improvements
-- Adjust initial criteria to ensure consistency
-- Adjust each player's content to ensure consistency
-- Support players with images or audio
-- Parallelize processing battles and scoring
-
-## Ranking Configuration
-
-| Config | Description | Default |
-|--------|-------------|---------|
-| `score_variation_threshold` | Threshold for eliminating players with inconsistent scores | `30` |
-
-## Ranking Callbacks
-Callbacks are optional and can be used to watch any changes in players, battles, or scoring.
-
-| Callback | Description |
-|--------|-------------|
-| `watch_players` | Callback to watch any changes in players |
-| `watch_battles` | Callback to watch any changes in battles |
-| `watch_scoring` | Callback to watch any changes in scoring |
-
-Example of callback usage:
-
-```ruby
-result = ActiveGenie::Ranking.call(
-  players,
-  criteria,
-  config: {
-    watch_players: ->(player) { puts player },
-    watch_battles: ->(battle) { puts battle },
-    watch_scoring: ->(scoring) { puts scoring }
-  }
-)
-```
-

data/lib/active_genie/scoring/README.md

@@ -1,76 +0,0 @@
-# Scoring
-Text evaluation system that provides detailed scoring and feedback using multiple expert reviewers.
-
-## Features
-- Multi-reviewer evaluation - Get scores and feedback from multiple AI-powered expert reviewers
-- Automatic reviewer selection - Smart recommendation of reviewers based on content and criteria
-- Detailed feedback - Comprehensive reasoning for each reviewer's score
-- Customizable weights - Adjust the importance of different reviewers' scores
-- Flexible criteria - Score text against any specified evaluation criteria
-
-## Basic Usage
-
-Score text using predefined reviewers:
-
-```ruby
-text = "The code implements a binary search algorithm with O(log n) complexity"
-criteria = "Evaluate technical accuracy and clarity"
-reviewers = ["Algorithm Expert", "Technical Writer"]
-
-result = ActiveGenie::Scoring.call(text, criteria, reviewers)
-# => {
-#      algorithm_expert_score: 95,
-#      algorithm_expert_reasoning: "Accurately describes binary search and its complexity",
-#      technical_writer_score: 90,
-#      technical_writer_reasoning: "Clear and concise explanation of the algorithm",
-#      final_score: 92.5
-#    }
-```
-
-## Automatic Reviewer Selection
-
-When no reviewers are specified, the system automatically recommends appropriate reviewers:
-
-```ruby
-text = "The patient shows signs of improved cardiac function"
-criteria = "Evaluate medical accuracy and clarity"
-
-result = ActiveGenie::Scoring.call(text, criteria)
-# => {
-#      cardiologist_score: 88,
-#      cardiologist_reasoning: "Accurate assessment of cardiac improvement",
-#      medical_writer_score: 85,
-#      medical_writer_reasoning: "Clear communication of medical findings",
-#      general_practitioner_score: 90,
-#      general_practitioner_reasoning: "Well-structured medical observation",
-#      final_score: 87.7
-#    }
-```
-
-## Interface
-
-### `.call(text, criteria, reviewers = [], config: {})`
-Main interface for scoring text content.
-
-#### Parameters
-- `text` [String] - The text content to be evaluated
-- `criteria` [String] - The evaluation criteria or rubric to assess against
-- `reviewers` [Array<String>] - Optional list of specific reviewers
-- `config` [Hash] - Additional configuration config
-
-### `RecommendedReviewers.call(text, criteria, config: {})`
-Recommends appropriate reviewers based on content and criteria.
-
-#### Parameters
-- `text` [String] - The text content to analyze
-- `criteria` [String] - The evaluation criteria
-- `config` [Hash] - Additional configuration config
-
-### Usage Notes
-- Best suited for objective evaluation of text content
-- Provides balanced scoring through multiple reviewers
-- Automatically handles reviewer selection when needed
-- Supports custom weighting of reviewer scores
-- Returns detailed reasoning for each score
-
-Performance Impact: Using multiple reviewers or requesting detailed feedback may increase processing time.