active_genie 0.0.3 → 0.0.10

data/lib/active_genie/league/players_collection.rb

@@ -0,0 +1,68 @@
+require_relative '../utils/math'
+require_relative './player'
+
+module ActiveGenie::Leaderboard
+  class PlayersCollection
+    def initialize(param_players)
+      @players = build(param_players)
+    end
+    attr_reader :players
+
+    def coefficient_of_variation
+      score_list = eligible.map(&:score)
+      mean = score_list.sum.to_f / score_list.size
+      return nil if mean == 0  # To avoid division by zero
+
+      variance = score_list.map { |num| (num - mean) ** 2 }.sum / score_list.size
+      standard_deviation = Math.sqrt(variance)
+
+      (standard_deviation / mean) * 100
+    end
+
+    def tier_relegation
+      eligible[(tier_size*-1)..-1]
+    end
+
+    def tier_defense
+      eligible[(tier_size*-2)...(tier_size*-1)]
+    end
+
+    def eligible
+      sorted.reject(&:eliminated)
+    end
+
+    def eligible_size
+      @players.reject(&:eliminated).size
+    end
+
+    def to_h
+      sorted.map(&:to_h)
+    end
+
+    def method_missing(...)
+      @players.send(...)
+    end
+
+    def sorted
+      @players.sort_by { |p| [-p.league_score, -(p.elo || 0), -p.score] }
+    end
+
+    private
+
+    def build(param_players)
+      param_players.map { |player| Player.new(player) }
+    end
+
+    # Returns the number of players to battle in each round
+    # based on the eligible size, start fast and go slow until top 10
+    # Example:
+    #   - 50 eligible, tier_size: 15
+    #   - 35 eligible, tier_size: 11 
+    #   - 24 eligible, tier_size: 10
+    #   - 14 eligible, tier_size: 4
+    #  4 rounds to reach top 10 with 50 players
+    def tier_size
+      [[(eligible_size / 3).ceil, 10].max, eligible_size - 10].min
+    end
+  end
+end

data/lib/active_genie/league.rb

@@ -0,0 +1,12 @@
+require_relative 'league/league'
+
+module ActiveGenie
+  # See the [league README](lib/active_genie/league/README.md) for more information.
+  module League
+    module_function
+
+    def call(...)
+      league.call(...)
+    end
+  end
+end

data/lib/active_genie/logger.rb

@@ -0,0 +1,45 @@
+require 'json'
+require 'fileutils'
+
+module ActiveGenie
+  module Logger
+    module_function
+
+    def info(log)
+      save(log, level: :info)
+    end
+
+    def error(log)
+      save(log, level: :error)
+    end
+
+    def warn(log)
+      save(log, level: :warn)
+    end
+
+    def debug(log)
+      save(log, level: :debug)
+    end
+
+    def trace(log)
+      save(log, level: :trace)
+    end
+
+    LOG_LEVELS = { info: 0, error: 1, warn: 2, debug: 3, trace: 4 }.freeze
+
+    def save(log, level: :info)
+      return if LOG_LEVELS[log.dig(:log, :log_level)] || -1 < LOG_LEVELS[level]
+
+      log[:trace] = log.dig(:trace)&.to_s&.gsub('ActiveGenie::', '')
+      log[:timestamp] = Time.now
+      log[:level] = level.to_s.upcase
+      log[:process_id] = Process.pid
+
+      FileUtils.mkdir_p('logs')
+      File.write('logs/active_genie.log', "#{JSON.generate(log)}\n", mode: 'a')
+      puts log
+
+      log
+    end
+  end
+end

data/lib/active_genie/scoring/README.md

@@ -49,26 +49,22 @@ result = ActiveGenie::Scoring::Basic.call(text, criteria)
 
 ## Interface
 
-### `Basic.call(text, criteria, reviewers = [], options: {})`
+### `Basic.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
-- `options` [Hash] - Additional configuration options
-  - `:detailed_feedback` [Boolean] - Request more detailed feedback (WIP)
-  - `:reviewer_weights` [Hash] - Custom weights for different reviewers (WIP)
+- `config` [Hash] - Additional configuration config
 
-### `RecommendedReviews.call(text, criteria, options: {})`
+### `RecommendedReviews.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
-- `options` [Hash] - Additional configuration options
-  - `:prefer_technical` [Boolean] - Favor technical expertise (WIP)
-  - `:prefer_domain` [Boolean] - Favor domain expertise (WIP)
+- `config` [Hash] - Additional configuration config
 
 ### Usage Notes
 - Best suited for objective evaluation of text content

data/lib/active_genie/scoring/basic.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../clients/router'
+require_relative '../clients/unified_client'
 
 module ActiveGenie::Scoring
   # The Basic class provides a foundation for scoring text content against specified criteria
@@ -17,24 +17,23 @@ module ActiveGenie::Scoring
   #   Basic.call("Sample text", "Evaluate technical accuracy")
   #
   class Basic
-    def self.call(text, criteria, reviewers = [], options: {})
-      new(text, criteria, reviewers, options:).call
-    end
-
-    # Initializes a new scoring evaluation instance
-    #
     # @param text [String] The text content to be evaluated
     # @param criteria [String] The evaluation criteria or rubric to assess against
     # @param reviewers [Array<String>] Optional list of specific reviewers. If empty,
     #   reviewers will be automatically recommended based on the content and criteria
-    # @param options [Hash] Additional configuration options that modify the scoring behavior
-    # @option options [Boolean] :detailed_feedback Request more detailed feedback in the reasoning
-    # @option options [Hash] :reviewer_weights Custom weights for different reviewers
-    def initialize(text, criteria, reviewers = [], options: {})
+    # @param config [Hash] Additional configuration config that modify the scoring behavior
+    # @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 reviewers
+    #   @return [String] :final_reasoning Detailed explanation of why the final score was reached
+    def self.call(text, criteria, reviewers = [], config: {})
+      new(text, criteria, reviewers, config:).call
+    end
+
+    def initialize(text, criteria, reviewers = [], config: {})
       @text = text
       @criteria = criteria
       @reviewers = Array(reviewers).compact.uniq
-      @options = options
+      @config = config
     end
 
     def call
@@ -77,7 +76,7 @@ module ActiveGenie::Scoring
         }
       }
 
-      ::ActiveGenie::Clients::Router.function_calling(messages, function, options: @options)
+      ::ActiveGenie::Clients::UnifiedClient.function_calling(messages, function, config:)
     end
 
     private
@@ -86,7 +85,7 @@ module ActiveGenie::Scoring
       @get_or_recommend_reviewers ||= if @reviewers.count > 0 
         @reviewers
       else
-        recommended_reviews = RecommendedReviews.call(@text, @criteria, options: @options)
+        recommended_reviews = RecommendedReviews.call(@text, @criteria, config:)
 
         [recommended_reviews[:reviewer1], recommended_reviews[:reviewer2], recommended_reviews[:reviewer3]]
       end
@@ -112,5 +111,16 @@ module ActiveGenie::Scoring
     - Deconstruct each criterion into actionable components for a systematic evaluation.
     - If the text lacks information, apply reasonable judgment to assign a score while clearly explaining the rationale.
     PROMPT
+
+    def config
+      {
+        all_providers: { model_tier: 'lower_tier' },
+        log: {
+          **(@config.dig(:log) || {}),
+          trace: self.class.name,
+        },
+        **@config
+      }
+    end
   end
 end

data/lib/active_genie/scoring/recommended_reviews.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../clients/router.rb'
+require_relative '../clients/unified_client'
 
 module ActiveGenie::Scoring
   # The RecommendedReviews class intelligently suggests appropriate reviewer roles
@@ -17,21 +17,19 @@ module ActiveGenie::Scoring
   #   #      reviewer3: "Developer Advocate", reasoning: "..." }
   #
   class RecommendedReviews
-    def self.call(text, criteria, options: {})
-      new(text, criteria, options:).call
+    def self.call(text, criteria, config: {})
+      new(text, criteria, config:).call
     end
 
     # Initializes a new reviewer recommendation instance
     #
     # @param text [String] The text content to analyze for reviewer recommendations
     # @param criteria [String] The evaluation criteria that will guide reviewer selection
-    # @param options [Hash] Additional configuration options that modify the recommendation process
-    # @option options [Boolean] :prefer_technical Whether to favor technical expertise
-    # @option options [Boolean] :prefer_domain Whether to favor domain expertise
-    def initialize(text, criteria, options: {})
+    # @param config [Hash] Additional configuration config that modify the recommendation process
+    def initialize(text, criteria, config: {})
       @text = text
       @criteria = criteria
-      @options = options
+      @config = config
     end
 
     def call
@@ -55,7 +53,7 @@ module ActiveGenie::Scoring
         }
       }
 
-      ::ActiveGenie::Clients::Router.function_calling(messages, function, options:)
+      ::ActiveGenie::Clients::UnifiedClient.function_calling(messages, function, config: @config)
     end
 
     private

data/lib/active_genie/scoring.rb

@@ -2,16 +2,16 @@ require_relative 'scoring/basic'
 require_relative 'scoring/recommended_reviews'
 
 module ActiveGenie
-  # Text evaluation system that provides detailed scoring and feedback using multiple expert reviewers
+  # See the [Scoring README](lib/active_genie/scoring/README.md) for more information.
   module Scoring
     module_function
 
-    def basic(text, criteria, reviewers = [], options: {})
-      Basic.call(text, criteria, reviewers, options:)
+    def basic(...)
+      Basic.call(...)
     end
 
-    def recommended_reviews(text, criteria, options: {})
-      RecommendedReviews.call(text, criteria, options:)
+    def recommended_reviews(...)
+      RecommendedReviews.call(...)
     end
   end
 end

data/lib/active_genie.rb

@@ -1,23 +1,26 @@
+require_relative 'active_genie/logger'
+require_relative 'active_genie/configuration'
+
 module ActiveGenie
   autoload :DataExtractor, File.join(__dir__, 'active_genie/data_extractor')
+  autoload :Battle, File.join(__dir__, 'active_genie/battle')
   autoload :Scoring, File.join(__dir__, 'active_genie/scoring')
-  autoload :Configuration, File.join(__dir__, 'active_genie/configuration')
+  autoload :Leaderboard, File.join(__dir__, 'active_genie/leaderboard')
 
   class << self
-    def config
-      @config ||= Configuration.new
-    end
-
     def configure
-      yield(config) if block_given?
+      yield(configuration) if block_given?
     end
-    
-    def [](key)
-      config.values[key.to_s]
+
+    def configuration
+      @configuration ||= Configuration
     end
 
-    def config_by_model(model)
-      config.values[model&.to_s&.downcase&.strip] || config.values.values.first || {}
+    def load_tasks
+      return unless defined?(Rake)
+
+      Rake::Task.define_task(:environment)
+      Dir.glob(File.join(__dir__, 'tasks', '*.rake')).each { |r| load r }
     end
   end
 end

data/lib/tasks/install.rake

@@ -3,10 +3,10 @@ require 'fileutils'
 namespace :active_genie do
   desc 'Install active_genie configuration file'
   task :install do
-    source = File.join('lib', 'tasks', 'templates', 'active_genie.yml')
-    target = File.join('config', 'active_genie.yml')
+    source = File.join(__dir__, 'templates', 'active_genie.rb')
+    target = File.join('config', 'initializers', 'active_genie.rb')
 
     FileUtils.cp(source, target)
-    puts "Successfully installed config/active_genie.yml to #{target}"
+    puts "Successfully installed active_genie!"
   end
 end

data/lib/tasks/templates/active_genie.rb

@@ -0,0 +1,17 @@
+
+ActiveGenie.configure do |config|
+  # example with openai and the current default for each config
+  # config.providers.openai.api_key = ENV['OPENAI_API_KEY']
+  # config.providers.openai.organization = ENV['OPENAI_ORGANIZATION']
+  # config.providers.openai.api_url = 'https://api.openai.com/v1'
+  # config.providers.openai.lower_tier_model = 'gpt-4o-mini'
+  # config.providers.openai.middle_tier_model = 'gpt-4o'
+  # config.providers.openai.upper_tier_model = 'o1-preview'
+  # config.providers.openai.client = ActiveGenie::Providers::Openai::Client.new(config)
+
+  # example how add a new provider
+  # config.providers.register(:internal_company_api, InternalCompanyApi::Configuration)
+
+  # Logs configuration
+  # config.log_level = :debug # default is :info
+end

metadata

@@ -1,22 +1,114 @@
 --- !ruby/object:Gem::Specification
 name: active_genie
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.10
 platform: ruby
 authors:
 - Radamés Roriz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-01-25 00:00:00.000000000 Z
+date: 2025-02-10 00:00:00.000000000 Z
 dependencies: []
-description: |2
-      ActiveGenie provides a robust toolkit for integrating AI capabilities into Ruby applications.
-      Features include:
-      * Structured data extraction from text
-      * Smart text summarization
-      * Content scoring and ranking
-      * AI-powered classification
+description: "# ActiveGenie \U0001F9DE‍♂️\n> Transform your Ruby application with
+  powerful, production-ready GenAI features\n\n[![Gem Version](https://badge.fury.io/rb/active_genie.svg?icon=si%3Arubygems)](https://badge.fury.io/rb/active_genie)\n[![Ruby](https://github.com/roriz/active_genie/actions/workflows/ruby.yml/badge.svg)](https://github.com/roriz/active_genie/actions/workflows/ruby.yml)\n\nActiveGenie
+  is a Ruby gem that provides a polished, production-ready interface for working with
+  Generative AI (GenAI) models. Just like ActiveStorage simplifies file handling in
+  Rails, ActiveGenie makes it effortless to integrate GenAI capabilities into your
+  Ruby applications.\n\n## Features\n\n- \U0001F3AF **Data Extraction**: Extract structured
+  data from unstructured text with type validation\n- \U0001F4CA **Smart Scoring**:
+  Multi-reviewer evaluation system with automatic expert selection\n- \U0001F4AD **Leaderboard**:
+  Consistent rank items based on custom criteria, using multiple tecniques of ranking\n\n##
+  Installation\n\n1. Add to your Gemfile:\n```ruby\ngem 'active_genie'\n```\n\n2.
+  Install the gem:\n```shell\nbundle install\n```\n\n3. Generate the configuration:\n```shell\necho
+  \"ActiveGenie.load_tasks\" >> Rakefile\nrails g active_genie:install\n```\n\n4.
+  Configure your credentials in `config/initializers/active_genie.rb`:\n```ruby\nActiveGenie.configure
+  do |config|\n  config.openai.api_key = ENV['OPENAI_API_KEY']\nend\n```\n\n## Quick
+  Start\n\n### Data Extractor\nExtract structured data from text using AI-powered
+  analysis, handling informal language and complex expressions.\n\n```ruby\ntext =
+  \"Nike Air Max 90 - Size 42 - $199.99\"\nschema = {\n  brand: { \n    type: 'string',\n
+  \   enum: [\"Nike\", \"Adidas\", \"Puma\"]\n  },\n  price: { \n    type: 'number',\n
+  \   minimum: 0\n  },\n  size: {\n    type: 'integer',\n    minimum: 35,\n    maximum:
+  46\n  }\n}\n\nresult = ActiveGenie::DataExtractor.call(text, schema)\n# => { \n#
+  \     brand: \"Nike\", \n#      brand_explanation: \"Brand name found at start of
+  text\",\n#      price: 199.99,\n#      price_explanation: \"Price found in USD format
+  at end\",\n#      size: 42,\n#      size_explanation: \"Size explicitly stated in
+  the middle\"\n#    }\n```\n\nFeatures:\n- Structured data extraction with type validation\n-
+  Schema-based extraction with custom constraints\n- Informal text analysis (litotes,
+  hedging)\n- Detailed explanations for extracted values\n\nSee the [Data Extractor
+  README](lib/active_genie/data_extractor/README.md) for informal text processing,
+  advanced schemas, and detailed interface documentation.\n\n### Scoring\nText 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.\n\n```ruby\ntext = \"The code implements a binary search algorithm
+  with O(log n) complexity\"\ncriteria = \"Evaluate technical accuracy and clarity\"\n\nresult
+  = ActiveGenie::Scoring.basic(text, criteria)\n# => {\n#      algorithm_expert_score:
+  95,\n#      algorithm_expert_reasoning: \"Accurately describes binary search and
+  its complexity\",\n#      technical_writer_score: 90,\n#      technical_writer_reasoning:
+  \"Clear and concise explanation of the algorithm\",\n#      final_score: 92.5\n#
+  \   }\n```\n\nFeatures:\n- Multi-reviewer evaluation with automatic expert selection\n-
+  Detailed feedback with scoring reasoning\n- Customizable reviewer weights\n- Flexible
+  evaluation criteria\n\nSee the [Scoring README](lib/active_genie/scoring/README.md)
+  for advanced usage, custom reviewers, and detailed interface documentation.\n\n###
+  Battle\nAI-powered battle evaluation system that determines winners between two
+  players based on specified criteria.\n\n```ruby\nrequire 'active_genie'\n\nplayer_a
+  = \"Implementation uses dependency injection for better testability\"\nplayer_b
+  = \"Code has high test coverage but tightly coupled components\"\ncriteria = \"Evaluate
+  code quality and maintainability\"\n\nresult = ActiveGenie::Battle.call(player_a,
+  player_b, criteria)\n# => {\n#      winner_player: \"Implementation uses dependency
+  injection for better testability\",\n#      reasoning: \"Player A's implementation
+  demonstrates better maintainability through dependency injection, \n#                 which
+  allows for easier testing and component replacement. While Player B has good test
+  coverage, \n#                 the tight coupling makes the code harder to maintain
+  and modify.\",\n#      what_could_be_changed_to_avoid_draw: \"Focus on specific
+  architectural patterns and design principles\"\n#    }\n```\n\nFeatures:\n- Multi-reviewer
+  evaluation with automatic expert selection\n- Detailed feedback with scoring reasoning\n-
+  Customizable reviewer weights\n- Flexible evaluation criteria\n\nSee the [Battle
+  README](lib/active_genie/battle/README.md) for advanced usage, custom reviewers,
+  and detailed interface documentation.\n\n### League\nThe League module provides
+  competitive ranking through multi-stage evaluation:\n\n\n```ruby\nrequire 'active_genie'\n\nplayers
+  = ['REST API', 'GraphQL API', 'SOAP API', 'gRPC API', 'Websocket API']\ncriteria
+  = \"Best one to be used into a high changing environment\"\n\nresult = ActiveGenie::League.call(players,
+  criteria)\n# => {\n#      winner_player: \"gRPC API\",\n#      reasoning: \"gRPC
+  API is the best one to be used into a high changing environment\",\n#    }\n```\n\n-
+  **Multi-phase ranking system** combining expert scoring and ELO algorithms\n- **Automatic
+  elimination** of inconsistent performers using statistical analysis\n- **Dynamic
+  ranking adjustments** based on simulated pairwise battles, from bottom to top\n\nSee
+  the [League README](lib/active_genie/league/README.md) for implementation details,
+  configuration, and advanced ranking strategies.\n\n### Summarizer (WIP)\nThe summarizer
+  is a tool that can be used to summarize a given text. It uses a set of rules to
+  summarize the text out of the box. Uses the best practices of prompt engineering
+  and engineering to make the summarization as accurate as possible.\n\n```ruby\nrequire
+  'active_genie'\n\ntext = \"Example text to be summarized. The fox jumps over the
+  dog\"\nsummarized_text = ActiveGenie::Summarizer.call(text)\nputs summarized_text
+  # => \"The fox jumps over the dog\"\n```\n\n### Language detector (WIP)\nThe language
+  detector is a tool that can be used to detect the language of a given text. It uses
+  a set of rules to detect the language of the text out of the box. Uses the best
+  practices of prompt engineering and engineering to make the language detection as
+  accurate as possible.\n\n```ruby\nrequire 'active_genie'\n\ntext = \"Example text
+  to be detected\"\nlanguage = ActiveGenie::LanguageDetector.call(text)\nputs language
+  # => \"en\"\n```\n\n### Translator (WIP)\nThe translator is a tool that can be used
+  to translate a given text. It uses a set of rules to translate the text out of the
+  box. Uses the best practices of prompt engineering and engineering to make the translation
+  as accurate as possible.\n\n```ruby\nrequire 'active_genie'\n\ntext = \"Example
+  text to be translated\"\ntranslated_text = ActiveGenie::Translator.call(text, from:
+  'en', to: 'pt')\nputs translated_text # => \"Exemplo de texto a ser traduzido\"\n```\n\n###
+  Sentiment analyzer (WIP)\nThe sentiment analyzer is a tool that can be used to analyze
+  the sentiment of a given text. It uses a set of rules to analyze the sentiment of
+  the text out of the box. Uses the best practices of prompt engineering and engineering
+  to make the sentiment analysis as accurate as possible.\n\n```ruby\nrequire 'active_genie'\n\ntext
+  = \"Example text to be analyzed\"\nsentiment = ActiveGenie::SentimentAnalyzer.call(text)\nputs
+  sentiment # => \"positive\"\n```\n\n## Configuration\n\n| Config | Description |
+  Default |\n|--------|-------------|---------|\n| `provider` | LLM provider (openai,
+  anthropic, etc) | `nil` |\n| `model` | Model to use | `nil` |\n| `api_key` | Provider
+  API key | `nil` |\n| `timeout` | Request timeout in seconds | `5` |\n| `max_retries`
+  | Maximum retry attempts | `3` |\n\n> **Note:** Each module can append its own set
+  of configuration, see the individual module documentation for details.\n\n## Contributing\n\n1.
+  Fork the repository\n2. Create your feature branch (`git checkout -b feature/amazing-feature`)\n3.
+  Commit your changes (`git commit -m 'Add amazing feature'`)\n4. Push to the branch
+  (`git push origin feature/amazing-feature`)\n5. Open a Pull Request\n## License\n\nThis
+  project is licensed under the MIT License - see the [LICENSE](LICENSE) file for
+  details.\n"
 email:
 - radames@roriz.dev
 executables: []
@@ -27,19 +119,33 @@ files:
 - README.md
 - VERSION
 - lib/active_genie.rb
-- lib/active_genie/clients/openai.rb
-- lib/active_genie/clients/router.rb
+- lib/active_genie/battle.rb
+- lib/active_genie/battle/README.md
+- lib/active_genie/battle/basic.rb
+- lib/active_genie/clients/openai_client.rb
+- lib/active_genie/clients/unified_client.rb
 - lib/active_genie/configuration.rb
+- lib/active_genie/configuration/log_config.rb
+- lib/active_genie/configuration/openai_config.rb
+- lib/active_genie/configuration/providers_config.rb
 - lib/active_genie/data_extractor.rb
 - lib/active_genie/data_extractor/README.md
 - lib/active_genie/data_extractor/basic.rb
 - lib/active_genie/data_extractor/from_informal.rb
+- lib/active_genie/league.rb
+- lib/active_genie/league/README.md
+- lib/active_genie/league/elo_ranking.rb
+- lib/active_genie/league/free_for_all.rb
+- lib/active_genie/league/league.rb
+- lib/active_genie/league/player.rb
+- lib/active_genie/league/players_collection.rb
+- lib/active_genie/logger.rb
 - lib/active_genie/scoring.rb
 - lib/active_genie/scoring/README.md
 - lib/active_genie/scoring/basic.rb
 - lib/active_genie/scoring/recommended_reviews.rb
 - lib/tasks/install.rake
-- lib/tasks/templates/active_ai.yml
+- lib/tasks/templates/active_genie.rb
 homepage: https://github.com/Roriz/active_genie
 licenses:
 - Apache-2.0
@@ -67,6 +173,5 @@ requirements: []
 rubygems_version: 3.5.3
 signing_key: 
 specification_version: 4
-summary: Modules and classes to help you build AI features, like data extraction,
-  summarization, scoring, and ranking.
+summary: Transform your Ruby application with powerful, production-ready GenAI features
 test_files: []

data/lib/active_genie/clients/openai.rb

@@ -1,59 +0,0 @@
-require 'json'
-require 'net/http'
-
-module ActiveGenie::Clients
-  class Openai
-    class << self
-      def function_calling(messages, function, options: {})
-        app_config = ActiveGenie.config_by_model(options[:model])
-
-        model = options[:model] || app_config[:model]
-        
-        raise "Model can't be blank" if model.nil?
-
-        payload = {
-          messages:,
-          response_format: {
-            type: 'json_schema',
-            json_schema: function
-          },
-          model:,
-        }
-
-        api_key = options[:api_key] || app_config[:api_key]
-
-        headers = DEFAULT_HEADERS.merge(
-          'Authorization': "Bearer #{api_key}"
-        ).compact
-
-        response = request(payload, headers)
-
-        JSON.parse(response.dig('choices', 0, 'message', 'content'))
-      rescue JSON::ParserError
-        nil
-      end
-
-      def request(payload, headers)
-        response = Net::HTTP.post(
-          URI(API_URL),
-          payload.to_json,
-          headers
-        )
-
-        raise OpenaiError, response.body unless response.is_a?(Net::HTTPSuccess)
-        return nil if response.body.empty?
-
-        JSON.parse(response.body)
-      end
-
-    end
-    
-    API_URL = 'https://api.openai.com/v1/chat/completions'.freeze
-    DEFAULT_HEADERS = {
-      'Content-Type': 'application/json',
-    }
-
-    # TODO: add some more rich error handling
-    class OpenaiError < StandardError; end
-  end
-end

data/lib/active_genie/clients/router.rb

@@ -1,41 +0,0 @@
-require_relative './openai'
-
-module ActiveGenie::Clients
-  class Router
-    class << self
-      def function_calling(messages, function, options: {})
-        app_config = ActiveGenie.config_by_model(options[:model])
-
-        provider = options[:provider] || app_config[:provider]
-        client = PROVIDER_TO_CLIENT[provider&.downcase&.strip&.to_sym]
-        raise "Provider \"#{provider}\" not supported" unless client
-
-        response = client.function_calling(messages, function, options:)
-
-        clear_invalid_values(response)
-      end
-
-      private
-
-      PROVIDER_TO_CLIENT = {
-        openai: Openai,
-      }
-
-      INVALID_VALUES = [
-        'not sure',
-        'not clear',
-        'not specified',
-        'none',
-        'null',
-        'undefined',
-      ].freeze
-
-      def clear_invalid_values(data)
-        data.reduce({}) do |acc, (field, value)|
-          acc[field] = value unless INVALID_VALUES.include?(value)
-          acc
-        end
-      end
-    end
-  end
-end

data/lib/tasks/templates/active_ai.yml

@@ -1,7 +0,0 @@
-# GPT-4o-mini:
-#   api_key: <%= ENV['OPENAI_API_KEY'] %>
-#   provider: 'openai'
-# 
-# claude-3-5-sonnet:
-#  api_key: <%= ENV['ANTHROPIC_API_KEY'] %>
-#  provider: 'anthropic'