active_genie 0.0.18 → 0.0.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81b6b3ccf366bdeb07e1dfc1942749e4a1d48da74735c48a95cb9d53afb61b33
-  data.tar.gz: df2d1ee4ac8bbcfa031b261bedd228ed5c3a8772c055e312360d6a4ad2f699fa
+  metadata.gz: d46586e4c64fdba00b703d32d2ee5eaad16e53e38f01adadb1a6090f049118d1
+  data.tar.gz: f8420784cfd4b4ce21b2217af31d3e46252d623a65f0e93194027d9fd416b8ca
 SHA512:
-  metadata.gz: d3a2ff8342483f8b475f0e60d91fa839ba57b0853e82e637ba4e761fd9ae749917e5ae134803200bfe3fd4bab658b297c1888c88d6c433d4f2c0a0694face6aa
-  data.tar.gz: a4b37bd1e6ba7a3a4b6edea20bd37f7e2dd11142182b65b8e62707e993d9c42d44486c2247e342ab8a81b01778456dd5bf15616261e01d6c0dd556757646da18
+  metadata.gz: 7ab8e0d11276d5805d9ea3568c4f0c2a15d23fed01d8d762b8750cb6a2bd2f6a698a929b13b6bdf8da30d4b2b81187ab61160be9250b7e709b827389f925a9e2
+  data.tar.gz: a6cddf62c9f6f19fe6fbe6982e8c6a2097b644280d0d86fea19e85da507e91b8dab3299304f182246f84c1cfa7c0e2e003c19781d827b66f15a5c34d10e36da5

data/README.md

@@ -137,7 +137,7 @@ result = ActiveGenie::Battle.call(
 #    }
 ```
 
-*Recommended model*: `gemini-2.0-flash-lite`
+*Recommended model*: `claude-3-5-haiku`
 
 Features:
 - Multi-reviewer evaluation with automatic expert selection
@@ -216,6 +216,64 @@ See the [Benchmark README](benchmark/README.md) for detailed results, methodolog
 
 > **Note:** Each module can append its own set of configuration, see the individual module documentation for details.
 
+## 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/`:
+
+```ruby
+# Example: lib/active_genie/configuration/providers/internal_company_api_config.rb
+module ActiveGenie
+  module Configuration::Providers
+    class InternalCompanyApiConfig < BaseConfig
+      NAME = :internal_company_api
+      
+      # API key accessor with environment variable fallback
+      def api_key
+        @api_key || ENV['INTERNAL_COMPANY_API_KEY']
+      end
+      
+      # Base API URL
+      def api_url
+        @api_url || 'https://api.internal-company.com/v1'
+      end
+      
+      # Client instantiation
+      def client
+        @client ||= ::ActiveGenie::Clients::InternalCompanyApiClient.new(self)
+      end
+      
+      # Model tier definitions
+      def lower_tier_model
+        @lower_tier_model || 'internal-basic'
+      end
+      
+      def middle_tier_model
+        @middle_tier_model || 'internal-standard'
+      end
+      
+      def upper_tier_model
+        @upper_tier_model || 'internal-premium'
+      end
+    end
+  end
+end
+```
+
+2. Register your provider in your configuration:
+
+```ruby
+# In config/initializers/active_genie.rb
+ActiveGenie.configure do |config|
+  # Register your custom provider
+  config.providers.register(InternalCompanyApi::Configuration)
+  
+  # Configure your provider
+  config.internal_company_api.api_key = ENV['INTERNAL_COMPANY_API_KEY']
+end
+```
+
 ## Contributing
 
 1. Fork the repository

data/VERSION

@@ -1 +1 @@
-0.0.18
+0.0.20

data/lib/active_genie/battle/basic.rb

@@ -94,7 +94,7 @@ module ActiveGenie::Battle
     FUNCTION =  {
       name: 'battle_evaluation',
       description: 'Evaluate a battle between player_1 and player_2 using predefined criteria and identify the winner.',
-      schema: {
+      parameters: {
         type: "object",
         properties: {
           player_1_sell_himself: {
@@ -122,15 +122,7 @@ module ActiveGenie::Battle
             description: 'Who is the winner based on the impartial judge reasoning?',
             enum: ['player_1', 'player_2']
           },
-        },
-        required: [
-          'player_1_sell_himself',
-          'player_2_sell_himself',
-          'player_1_arguments',
-          'player_2_counter',
-          'impartial_judge_winner_reasoning',
-          'impartial_judge_winner'
-        ]
+        }
       }
     }
   end

data/lib/active_genie/clients/anthropic_client.rb

@@ -2,108 +2,82 @@ require 'json'
 require 'net/http'
 require 'uri'
 require_relative './helpers/retry'
+require_relative './base_client'
 
-module ActiveGenie
-  module Clients
-    # Client for interacting with the Anthropic (Claude) API with json response
-    class AnthropicClient
-      class AnthropicError < StandardError; end
-      class RateLimitError < AnthropicError; end
+module ActiveGenie::Clients
+  # Client for interacting with the Anthropic (Claude) API with json response
+  class AnthropicClient < BaseClient
+    class AnthropicError < ClientError; end
+    class RateLimitError < AnthropicError; end
 
-      def initialize(config)
-        @app_config = config
-      end
-
-      # Requests structured JSON output from the Anthropic Claude model based on a schema.
-      #
-      # @param messages [Array<Hash>] A list of messages representing the conversation history.
-      #   Each hash should have :role ('user', 'assistant', or 'system') and :content (String).
-      #   Claude uses 'user', 'assistant', and 'system' roles.
-      # @param function [Hash] A JSON schema definition describing the desired output format.
-      # @param model_tier [Symbol, nil] A symbolic representation of the model quality/size tier.
-      # @param config [Hash] Optional configuration overrides:
-      #   - :api_key [String] Override the default API key.
-      #   - :model [String] Override the model name directly.
-      #   - :max_retries [Integer] Max retries for the request.
-      #   - :retry_delay [Integer] Initial delay for retries.
-      #   - :anthropic_version [String] Override the default Anthropic API version.
-      # @return [Hash, nil] The parsed JSON object matching the schema, or nil if parsing fails or content is empty.
-      def function_calling(messages, function, model_tier: nil, config: {})
-        model = config[:runtime][:model] || @app_config.tier_to_model(model_tier)
-
-        system_message = messages.find { |m| m[:role] == 'system' }&.dig(:content) || ''
-        user_messages = messages.select { |m| m[:role] == 'user' || m[:role] == 'assistant' }
-          .map { |m| { role: m[:role], content: m[:content] } }
-
-        anthropic_function = function
-        anthropic_function[:input_schema] = function[:schema]
-        anthropic_function.delete(:schema)
-
-        payload = {
-          model:,
-          system: system_message,
-          messages: user_messages,
-          tools: [anthropic_function],
-          tool_choice: { name: anthropic_function[:name], type: 'tool' },
-          max_tokens: config[:runtime][:max_tokens],
-          temperature: config[:runtime][:temperature] || 0,
-        }
-
-        api_key = config[:runtime][:api_key] || @app_config.api_key
-        headers = DEFAULT_HEADERS.merge(
-          'x-api-key': api_key,
-          'anthropic-version': config[:anthropic_version] || ANTHROPIC_VERSION
-        ).compact
+    ANTHROPIC_VERSION = '2023-06-01'
+    ANTHROPIC_ENDPOINT = '/v1/messages'
 
-        retry_with_backoff(config:) do
-          response = request(payload, headers, config:)
-          content = response.dig('content', 0, 'input')
-
-          ActiveGenie::Logger.trace({code: :function_calling, payload:, parsed_response: content})
-        
-          content
-        end
-      end
-
-      private
+    def initialize(config)
+      super(config)
+    end
 
-      DEFAULT_HEADERS = {
-        'Content-Type': 'application/json',
+    # Requests structured JSON output from the Anthropic Claude model based on a schema.
+    #
+    # @param messages [Array<Hash>] A list of messages representing the conversation history.
+    #   Each hash should have :role ('user', 'assistant', or 'system') and :content (String).
+    #   Claude uses 'user', 'assistant', and 'system' roles.
+    # @param function [Hash] A JSON schema definition describing the desired output format.
+    # @param model_tier [Symbol, nil] A symbolic representation of the model quality/size tier.
+    # @param config [Hash] Optional configuration overrides:
+    #   - :api_key [String] Override the default API key.
+    #   - :model [String] Override the model name directly.
+    #   - :max_retries [Integer] Max retries for the request.
+    #   - :retry_delay [Integer] Initial delay for retries.
+    #   - :anthropic_version [String] Override the default Anthropic API version.
+    # @return [Hash, nil] The parsed JSON object matching the schema, or nil if parsing fails or content is empty.
+    def function_calling(messages, function, model_tier: nil, config: {})
+      model = config[:runtime][:model] || @app_config.tier_to_model(model_tier)
+
+      system_message = messages.find { |m| m[:role] == 'system' }&.dig(:content) || ''
+      user_messages = messages.select { |m| m[:role] == 'user' || m[:role] == 'assistant' }
+        .map { |m| { role: m[:role], content: m[:content] } }
+
+      anthropic_function = function.dup
+      anthropic_function[:input_schema] = function[:parameters]
+      anthropic_function.delete(:parameters)
+
+      payload = {
+        model:,
+        system: system_message,
+        messages: user_messages,
+        tools: [anthropic_function],
+        tool_choice: { name: anthropic_function[:name], type: 'tool' },
+        max_tokens: config[:runtime][:max_tokens],
+        temperature: config[:runtime][:temperature] || 0,
       }
-      ANTHROPIC_VERSION = '2023-06-01'
 
-      def request(payload, headers, config:)
-        start_time = Time.now
-
-        retry_with_backoff(config:) do
-          response = Net::HTTP.post(
-            URI("#{@app_config.api_url}/v1/messages"),
-            payload.to_json,
-            headers
-          )
-
-          if response.is_a?(Net::HTTPTooManyRequests)
-            raise RateLimitError, "Anthropic API rate limit exceeded: #{response.body}"
-          end
-
-          raise AnthropicError, response.body unless response.is_a?(Net::HTTPSuccess)
-
-          return nil if response.body.empty?
-
-          parsed_body = JSON.parse(response.body)
+      api_key = config[:runtime][:api_key] || @app_config.api_key
+      headers = {
+        'x-api-key': api_key,
+        'anthropic-version': config[:anthropic_version] || ANTHROPIC_VERSION
+      }.compact
 
-          ActiveGenie::Logger.trace({
-            code: :llm_usage,
-            input_tokens: parsed_body.dig('usage', 'input_tokens'),
-            output_tokens: parsed_body.dig('usage', 'output_tokens'),
-            total_tokens: parsed_body.dig('usage', 'input_tokens') + parsed_body.dig('usage', 'output_tokens'),
-            model: payload[:model],
-            duration: Time.now - start_time,
-            usage: parsed_body.dig('usage')
-          })
-
-          parsed_body
-        end
+      retry_with_backoff(config:) do
+        start_time = Time.now
+        
+        response = post(ANTHROPIC_ENDPOINT, payload, headers: headers, config: config)
+        
+        content = response.dig('content', 0, 'input')
+        
+        ActiveGenie::Logger.trace({
+          code: :llm_usage,
+          input_tokens: response.dig('usage', 'input_tokens'),
+          output_tokens: response.dig('usage', 'output_tokens'),
+          total_tokens: response.dig('usage', 'input_tokens') + response.dig('usage', 'output_tokens'),
+          model: payload[:model],
+          duration: Time.now - start_time,
+          usage: response.dig('usage')
+        })
+
+        ActiveGenie::Logger.trace({code: :function_calling, payload:, parsed_response: content})
+      
+        content
       end
     end
   end

data/lib/active_genie/clients/base_client.rb

@@ -0,0 +1,241 @@
+module ActiveGenie
+  module Clients
+    class BaseClient
+      class ClientError < StandardError; end
+      class RateLimitError < ClientError; end
+      class TimeoutError < ClientError; end
+      class NetworkError < ClientError; end
+
+      DEFAULT_HEADERS = {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+        'User-Agent': 'ActiveGenie/1.0',
+      }.freeze
+
+      DEFAULT_TIMEOUT = 60 # seconds
+      DEFAULT_OPEN_TIMEOUT = 10 # seconds
+      DEFAULT_MAX_RETRIES = 3
+      DEFAULT_RETRY_DELAY = 1 # seconds
+
+      attr_reader :app_config
+
+      def initialize(config)
+        @app_config = config
+      end
+
+      # Make a GET request to the specified endpoint
+      #
+      # @param endpoint [String] The API endpoint to call
+      # @param headers [Hash] Additional headers to include in the request
+      # @param params [Hash] Query parameters for the request
+      # @param config [Hash] Configuration options including timeout, retries, etc.
+      # @return [Hash, nil] The parsed JSON response or nil if empty
+      def get(endpoint, params: {}, headers: {}, config: {})
+        uri = build_uri(endpoint, params)
+        request = Net::HTTP::Get.new(uri)
+        execute_request(uri, request, headers, config)
+      end
+
+      # Make a POST request to the specified endpoint
+      #
+      # @param endpoint [String] The API endpoint to call
+      # @param payload [Hash] The request body to send
+      # @param headers [Hash] Additional headers to include in the request
+      # @param config [Hash] Configuration options including timeout, retries, etc.
+      # @return [Hash, nil] The parsed JSON response or nil if empty
+      def post(endpoint, payload, params: {}, headers: {}, config: {})
+        uri = build_uri(endpoint, params)
+        request = Net::HTTP::Post.new(uri)
+        request.body = payload.to_json
+        execute_request(uri, request, headers, config)
+      end
+
+      # Make a PUT request to the specified endpoint
+      #
+      # @param endpoint [String] The API endpoint to call
+      # @param payload [Hash] The request body to send
+      # @param headers [Hash] Additional headers to include in the request
+      # @param config [Hash] Configuration options including timeout, retries, etc.
+      # @return [Hash, nil] The parsed JSON response or nil if empty
+      def put(endpoint, payload, headers: {}, config: {})
+        uri = build_uri(endpoint)
+        request = Net::HTTP::Put.new(uri)
+        request.body = payload.to_json
+        execute_request(uri, request, headers, config)
+      end
+
+      # Make a DELETE request to the specified endpoint
+      #
+      # @param endpoint [String] The API endpoint to call
+      # @param headers [Hash] Additional headers to include in the request
+      # @param params [Hash] Query parameters for the request
+      # @param config [Hash] Configuration options including timeout, retries, etc.
+      # @return [Hash, nil] The parsed JSON response or nil if empty
+      def delete(endpoint, headers: {}, params: {}, config: {})
+        uri = build_uri(endpoint, params)
+        request = Net::HTTP::Delete.new(uri)
+        execute_request(uri, request, headers, config)
+      end
+
+      protected
+
+      # Execute a request with retry logic and proper error handling
+      #
+      # @param uri [URI] The URI for the request
+      # @param request [Net::HTTP::Request] The request object
+      # @param headers [Hash] Additional headers to include
+      # @param config [Hash] Configuration options
+      # @return [Hash, nil] The parsed JSON response or nil if empty
+      def execute_request(uri, request, headers, config)
+        start_time = Time.now
+        
+        # Apply headers
+        apply_headers(request, headers)
+        
+        # Apply retry logic
+        retry_with_backoff(config) do
+          http = create_http_client(uri, config)
+          
+          begin
+            response = http.request(request)
+            
+            # Handle common HTTP errors
+            case response
+            when Net::HTTPSuccess
+              parsed_response = parse_response(response)
+              
+              # Log request details if logging is enabled
+              log_request_details(
+                uri: uri, 
+                method: request.method,
+                status: response.code,
+                duration: Time.now - start_time,
+                response: parsed_response
+              )
+              
+              parsed_response
+            when Net::HTTPTooManyRequests
+              raise RateLimitError, "Rate limit exceeded: #{response.body}"
+            when Net::HTTPClientError, Net::HTTPServerError
+              raise ClientError, "HTTP Error #{response.code}: #{response.body}"
+            else
+              raise ClientError, "Unexpected response: #{response.code} - #{response.body}"
+            end
+          rescue Timeout::Error, Errno::ETIMEDOUT
+            raise TimeoutError, "Request to #{uri} timed out"
+          rescue Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::EHOSTUNREACH, SocketError => e
+            raise NetworkError, "Network error: #{e.message}"
+          end
+        end
+      end
+
+      # Create and configure an HTTP client
+      #
+      # @param uri [URI] The URI for the request
+      # @param config [Hash] Configuration options
+      # @return [Net::HTTP] Configured HTTP client
+      def create_http_client(uri, config)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == 'https')
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        http.read_timeout = config.dig(:runtime, :timeout) || DEFAULT_TIMEOUT
+        http.open_timeout = config.dig(:runtime, :open_timeout) || DEFAULT_OPEN_TIMEOUT
+        http
+      end
+
+      # Apply headers to the request
+      #
+      # @param request [Net::HTTP::Request] The request object
+      # @param headers [Hash] Additional headers to include
+      def apply_headers(request, headers)
+        DEFAULT_HEADERS.each do |key, value|
+          request[key] = value
+        end
+        
+        headers.each do |key, value|
+          request[key.to_s] = value
+        end
+      end
+
+      # Build a URI for the request
+      #
+      # @param endpoint [String] The API endpoint
+      # @param params [Hash] Query parameters
+      # @return [URI] The constructed URI
+      def build_uri(endpoint, params = {})
+        base_url = @app_config.api_url
+        uri = URI("#{base_url}#{endpoint}")
+        
+        unless params.empty?
+          uri.query = URI.encode_www_form(params)
+        end
+        
+        uri
+      end
+
+      # Parse the response body
+      #
+      # @param response [Net::HTTPResponse] The HTTP response
+      # @return [Hash, nil] Parsed JSON or nil if empty
+      def parse_response(response)
+        return nil if response.body.nil? || response.body.empty?
+        
+        begin
+          JSON.parse(response.body)
+        rescue JSON::ParserError => e
+          raise ClientError, "Failed to parse JSON response: #{e.message}"
+        end
+      end
+
+      # Log request details if logging is enabled
+      #
+      # @param details [Hash] Request and response details
+      def log_request_details(details)
+        return unless defined?(ActiveGenie::Logger)
+        
+        ActiveGenie::Logger.trace({
+          code: :http_request,
+          uri: details[:uri].to_s,
+          method: details[:method],
+          status: details[:status],
+          duration: details[:duration],
+          response_size: details[:response].to_s.bytesize
+        })
+      end
+
+      # Retry a block with exponential backoff
+      #
+      # @param config [Hash] Configuration options
+      # @yield The block to retry
+      # @return [Object] The result of the block
+      def retry_with_backoff(config = {})
+        max_retries = config.dig(:runtime, :max_retries) || DEFAULT_MAX_RETRIES
+        retry_delay = config.dig(:runtime, :retry_delay) || DEFAULT_RETRY_DELAY
+        
+        retries = 0
+        
+        begin
+          yield
+        rescue RateLimitError, NetworkError => e
+          if retries < max_retries
+            sleep_time = retry_delay * (2 ** retries)
+            retries += 1
+            
+            ActiveGenie::Logger.trace({
+              code: :retry_attempt,
+              attempt: retries,
+              max_retries: max_retries,
+              delay: sleep_time,
+              error: e.message
+            }) if defined?(ActiveGenie::Logger)
+            
+            sleep(sleep_time)
+            retry
+          else
+            raise
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_genie/clients/google_client.rb

@@ -2,157 +2,134 @@ require 'json'
 require 'net/http'
 require 'uri'
 require_relative './helpers/retry'
+require_relative './base_client'
 
-module ActiveGenie
-  module Clients
-    # Client for interacting with the Google Generative Language API.
-    class GoogleClient
-      class GoogleError < StandardError; end
-      class RateLimitError < GoogleError; end
+module ActiveGenie::Clients
+  # Client for interacting with the Google Generative Language API.
+  class GoogleClient < BaseClient
+    class GoogleError < ClientError; end
+    class RateLimitError < GoogleError; end
 
-      API_VERSION_PATH = '/v1beta/models'.freeze
-      DEFAULT_HEADERS = {
-        'Content-Type': 'application/json',
-      }.freeze
+    API_VERSION_PATH = '/v1beta/models'.freeze
 
-      def initialize(config)
-        @app_config = config
-      end
+    def initialize(config)
+      super(config)
+    end
 
-      # Requests structured JSON output from the Google Generative Language model based on a schema.
-      #
-      # @param messages [Array<Hash>] A list of messages representing the conversation history.
-      #   Each hash should have :role ('user' or 'model') and :content (String).
-      #   Google Generative Language uses 'user' and 'model' roles.
-      # @param function [Hash] A JSON schema definition describing the desired output format.
-      # @param model_tier [Symbol, nil] A symbolic representation of the model quality/size tier.
-      # @param config [Hash] Optional configuration overrides:
-      #   - :api_key [String] Override the default API key.
-      #   - :model [String] Override the model name directly.
-      #   - :max_retries [Integer] Max retries for the request.
-      #   - :retry_delay [Integer] Initial delay for retries.
-      # @return [Hash, nil] The parsed JSON object matching the schema, or nil if parsing fails or content is empty.
-      def function_calling(messages, function, model_tier: nil, config: {})
-        model = config[:runtime][:model] || @app_config.tier_to_model(model_tier)
-        api_key = config[:runtime][:api_key] || @app_config.api_key
-
-        contents = convert_messages_to_contents(messages, function)
-        contents << output_as_json_schema(function)
-
-        payload = {
-          contents: contents,
-          generationConfig: {
-            response_mime_type: "application/json",
-            temperature: 0.1
-          }
+    # Requests structured JSON output from the Google Generative Language model based on a schema.
+    #
+    # @param messages [Array<Hash>] A list of messages representing the conversation history.
+    #   Each hash should have :role ('user' or 'model') and :content (String).
+    #   Google Generative Language uses 'user' and 'model' roles.
+    # @param function [Hash] A JSON schema definition describing the desired output format.
+    # @param model_tier [Symbol, nil] A symbolic representation of the model quality/size tier.
+    # @param config [Hash] Optional configuration overrides:
+    #   - :api_key [String] Override the default API key.
+    #   - :model [String] Override the model name directly.
+    #   - :max_retries [Integer] Max retries for the request.
+    #   - :retry_delay [Integer] Initial delay for retries.
+    # @return [Hash, nil] The parsed JSON object matching the schema, or nil if parsing fails or content is empty.
+    def function_calling(messages, function, model_tier: nil, config: {})
+      model = config[:runtime][:model] || @app_config.tier_to_model(model_tier)
+      api_key = config[:runtime][:api_key] || @app_config.api_key
+
+      contents = convert_messages_to_contents(messages, function)
+      contents << output_as_json_schema(function)
+
+      payload = {
+        contents: contents,
+        generationConfig: {
+          response_mime_type: "application/json",
+          temperature: 0.1
         }
+      }
 
-        url = URI("#{@app_config.api_url}#{API_VERSION_PATH}/#{model}:generateContent?key=#{api_key}")
+      endpoint = "#{API_VERSION_PATH}/#{model}:generateContent"
+      params = { key: api_key }
+      headers = DEFAULT_HEADERS
 
-        retry_with_backoff(config:) do
-          response = request(url, payload, model, config:)
+      retry_with_backoff(config:) do
+        start_time = Time.now
+        
+        response = post(endpoint, payload, headers:, params:, config: config)
+        
+        json_string = response&.dig('candidates', 0, 'content', 'parts', 0, 'text')
+        return nil if json_string.nil? || json_string.empty?
 
-          json_string = response&.dig('candidates', 0, 'content', 'parts', 0, 'text')
-  
-          return nil if json_string.nil? || json_string.empty?
-  
+        begin
           parsed_response = JSON.parse(json_string)
-  
+          
+          # Log usage metrics
+          usage_metadata = response['usageMetadata'] || {}
+          prompt_tokens = usage_metadata['promptTokenCount'] || 0
+          candidates_tokens = usage_metadata['candidatesTokenCount'] || 0
+          total_tokens = usage_metadata['totalTokenCount'] || (prompt_tokens + candidates_tokens)
+
+          ActiveGenie::Logger.trace({
+            code: :llm_usage,
+            input_tokens: prompt_tokens,
+            output_tokens: candidates_tokens,
+            total_tokens: total_tokens,
+            model: model,
+            duration: Time.now - start_time,
+            usage: usage_metadata
+          })
+          
           ActiveGenie::Logger.trace({ code: :function_calling, payload:, parsed_response: })
-
+          
           normalize_function_output(parsed_response)
+        rescue JSON::ParserError => e
+          raise GoogleError, "Failed to parse Google API response: #{e.message} - Content: #{json_string}"
         end
       end
+    end
 
-      private
-
-      def normalize_function_output(output)
-        output = if output.is_a?(Array)
-          output.dig(0, 'properties') || output.dig(0)
-        else
-          output
-        end
+    private
 
-        output.dig('input_schema', 'properties') || output
+    def normalize_function_output(output)
+      output = if output.is_a?(Array)
+        output.dig(0, 'properties') || output.dig(0)
+      else
+        output
       end
 
-      def request(url, payload, model, config:)
-        start_time = Time.now
-
-        retry_with_backoff(config:) do
-          response = Net::HTTP.post(url, payload.to_json, DEFAULT_HEADERS)
-
-          case response
-          when Net::HTTPSuccess
-            return nil if response.body.nil? || response.body.empty?
-
-            parsed_body = JSON.parse(response.body)
-
-            usage_metadata = parsed_body['usageMetadata'] || {}
-            prompt_tokens = usage_metadata['promptTokenCount'] || 0
-            candidates_tokens = usage_metadata['candidatesTokenCount'] || 0
-            total_tokens = usage_metadata['totalTokenCount'] || (prompt_tokens + candidates_tokens)
-
-            ActiveGenie::Logger.trace({
-              code: :llm_usage,
-              input_tokens: prompt_tokens,
-              output_tokens: candidates_tokens,
-              total_tokens: total_tokens,
-              model: model,
-              duration: Time.now - start_time,
-              usage: usage_metadata # Log the whole usage block
-            })
-
-            parsed_body
-
-          when Net::HTTPTooManyRequests
-            # Rate Limit Error
-            raise RateLimitError, "Google API rate limit exceeded (HTTP 429): #{response.body}"
-
-          else
-            # Other Errors
-            raise GoogleError, "Google API error (HTTP #{response.code}): #{response.body}"
-          end
-        end
-      rescue JSON::ParserError => e
-          raise GoogleError, "Failed to parse Google API response body: #{e.message} - Body: #{response&.body}"
-      end
+      output.dig('input_schema', 'properties') || output
+    end
 
-      ROLE_TO_GOOGLE_ROLE = {
-        user: 'user',
-        assistant: 'model',
-      }.freeze
-
-      # Converts standard message format to Google's 'contents' format
-      # and injects JSON schema instructions.
-      # @param messages [Array<Hash>] Array of { role: 'user'/'assistant'/'system', content: '...' }
-      # @param function_schema [Hash] The JSON schema for the desired output.
-      # @return [Array<Hash>] Array formatted for Google's 'contents' field.
-      def convert_messages_to_contents(messages, function_schema)
-        messages.map do |message|
-          {
-            role: ROLE_TO_GOOGLE_ROLE[message[:role].to_sym] || 'user',
-            parts: [{ text: message[:content] }]
-          }
-        end
+    ROLE_TO_GOOGLE_ROLE = {
+      user: 'user',
+      assistant: 'model',
+    }.freeze
+
+    # Converts standard message format to Google's 'contents' format
+    # and injects JSON schema instructions.
+    # @param messages [Array<Hash>] Array of { role: 'user'/'assistant'/'system', content: '...' }
+    # @param function_schema [Hash] The JSON schema for the desired output.
+    # @return [Array<Hash>] Array formatted for Google's 'contents' field.
+    def convert_messages_to_contents(messages, function_schema)
+      messages.map do |message|
+        {
+          role: ROLE_TO_GOOGLE_ROLE[message[:role].to_sym] || 'user',
+          parts: [{ text: message[:content] }]
+        }
       end
+    end
 
-      def output_as_json_schema(function_schema)
-        json_instruction = <<~PROMPT
-          Generate a JSON object that strictly adheres to the following JSON schema:
+    def output_as_json_schema(function_schema)
+      json_instruction = <<~PROMPT
+        Generate a JSON object that strictly adheres to the following JSON schema:
 
-          ```json
-          #{JSON.pretty_generate(function_schema)}
-          ```
+        ```json
+        #{JSON.pretty_generate(function_schema[:parameters])}
+        ```
 
-          IMPORTANT: Only output the raw JSON object. Do not include any other text, explanations, or markdown formatting like ```json ... ``` wrappers around the final output.
-        PROMPT
+        IMPORTANT: Only output the raw JSON object. Do not include any other text, explanations, or markdown formatting like ```json ... ``` wrappers around the final output.
+      PROMPT
 
-        {
-          role: 'user',
-          parts: [{ text: json_instruction }]
-        }
-      end
+      {
+        role: 'user',
+        parts: [{ text: json_instruction }]
+      }
     end
   end
 end

data/lib/active_genie/clients/openai_client.rb

@@ -2,48 +2,58 @@ require 'json'
 require 'net/http'
 
 require_relative './helpers/retry'
+require_relative './base_client'
 
 module ActiveGenie::Clients
-  class OpenaiClient    
-    class OpenaiError < StandardError; end
+  class OpenaiClient < BaseClient
+    class OpenaiError < ClientError; end
     class RateLimitError < OpenaiError; end
     class InvalidResponseError < StandardError; end
 
     def initialize(config)
-      @app_config = config
+      super(config)
     end
 
-      # Requests structured JSON output from the Gemini model based on a schema.
-      #
-      # @param messages [Array<Hash>] A list of messages representing the conversation history.
-      #   Each hash should have :role ('user' or 'model') and :content (String).
-      #   Gemini uses 'user' and 'model' roles.
-      # @param function [Hash] A JSON schema definition describing the desired output format.
-      # @param model_tier [Symbol, nil] A symbolic representation of the model quality/size tier.
-      # @param config [Hash] Optional configuration overrides:
-      #   - :api_key [String] Override the default API key.
-      #   - :model [String] Override the model name directly.
-      #   - :max_retries [Integer] Max retries for the request.
-      #   - :retry_delay [Integer] Initial delay for retries.
-      # @return [Hash, nil] The parsed JSON object matching the schema, or nil if parsing fails or content is empty.
+    # Requests structured JSON output from the OpenAI model based on a schema.
+    #
+    # @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.
+    # @param model_tier [Symbol, nil] A symbolic representation of the model quality/size tier.
+    # @param config [Hash] Optional configuration overrides:
+    #   - :api_key [String] Override the default API key.
+    #   - :model [String] Override the model name directly.
+    #   - :max_retries [Integer] Max retries for the request.
+    #   - :retry_delay [Integer] Initial delay for retries.
+    # @return [Hash, nil] The parsed JSON object matching the schema, or nil if parsing fails or content is empty.
     def function_calling(messages, function, model_tier: nil, config: {})
       model = config[:runtime][:model] || @app_config.tier_to_model(model_tier)
 
       payload = {
         messages:,
-        tools: [{ type: 'function', function: }],
+        tools: [{
+          type: 'function',
+          function: {
+            **function,
+            parameters: {
+              **function[:parameters],
+              additionalProperties: false
+            },
+            strict: true
+          }.compact
+        }],
         tool_choice: { type: 'function', function: { name: function[:name] } },
         stream: false,
         model:,
       }
 
       api_key = config[:runtime][:api_key] || @app_config.api_key
-      headers = DEFAULT_HEADERS.merge(
+      headers = {
         'Authorization': "Bearer #{api_key}"
-      ).compact
+      }.compact
 
       retry_with_backoff(config:) do
-        response = request(payload, headers, config:)
+        response = request_openai(payload, headers, config:)
 
         parsed_response = JSON.parse(response.dig('choices', 0, 'message', 'tool_calls', 0, 'function', 'arguments'))
         parsed_response = parsed_response.dig('message') || parsed_response
@@ -56,42 +66,33 @@ module ActiveGenie::Clients
       end
     end
 
-    private
 
-    DEFAULT_HEADERS = {
-      'Content-Type': 'application/json',
-    }
+    private
 
-    def request(payload, headers, config:)
+    # Make a request to the OpenAI API
+    #
+    # @param payload [Hash] The request payload
+    # @param headers [Hash] Additional headers
+    # @param config [Hash] Configuration options
+    # @return [Hash] The parsed response
+    def request_openai(payload, headers, config:)
       start_time = Time.now
 
-      response = Net::HTTP.post(
-        URI("#{@app_config.api_url}/chat/completions"),
-        payload.to_json,
-        headers
-      )
-
-      if response.is_a?(Net::HTTPTooManyRequests)
-        raise RateLimitError, "OpenAI API rate limit exceeded: #{response.body}"
-      end
-
-      raise OpenaiError, response.body unless response.is_a?(Net::HTTPSuccess)
-
-      return nil if response.body.empty?
+      response = post("/chat/completions", payload, headers: headers, config: config)
 
-      parsed_body = JSON.parse(response.body)
+      return nil if response.nil?
 
       ActiveGenie::Logger.trace({
         code: :llm_usage,
-        input_tokens: parsed_body.dig('usage', 'prompt_tokens'),
-        output_tokens: parsed_body.dig('usage', 'completion_tokens'),
-        total_tokens: parsed_body.dig('usage', 'prompt_tokens') + parsed_body.dig('usage', 'completion_tokens'),
+        input_tokens: response.dig('usage', 'prompt_tokens'),
+        output_tokens: response.dig('usage', 'completion_tokens'),
+        total_tokens: response.dig('usage', 'total_tokens'),
         model: payload[:model],
         duration: Time.now - start_time,
-        usage: parsed_body.dig('usage')
+        usage: response.dig('usage')
       })
 
-      parsed_body
+      response
     end
   end
 end

data/lib/active_genie/configuration/providers/internal_company_api_config.rb

@@ -0,0 +1,54 @@
+require_relative '../../clients/internal_company_api_client'
+require_relative './base_config'
+
+module ActiveGenie
+  module Configuration::Providers
+    # Configuration class for the Internal Company API client.
+    # Manages API keys, URLs, model selections, and client instantiation.
+    class InternalCompanyApiConfig < BaseConfig
+      NAME = :internal_company_api
+
+      # Retrieves the API key.
+      # Falls back to the INTERNAL_COMPANY_API_KEY environment variable if not set.
+      # @return [String, nil] The API key.
+      def api_key
+        @api_key || ENV['INTERNAL_COMPANY_API_KEY']
+      end
+
+      # Retrieves the base API URL for Internal Company API.
+      # Defaults to 'https://api.internal-company.com/v1'.
+      # @return [String] The API base URL.
+      def api_url
+        @api_url || 'https://api.internal-company.com/v1'
+      end
+
+      # Lazily initializes and returns an instance of the InternalCompanyApiClient.
+      # Passes itself (the config object) to the client's constructor.
+      # @return [ActiveGenie::Clients::InternalCompanyApiClient] The client instance.
+      def client
+        @client ||= ::ActiveGenie::Clients::InternalCompanyApiClient.new(self)
+      end
+
+      # Retrieves the model name designated for the lower tier (e.g., cost-effective, faster).
+      # Defaults to 'internal-basic'.
+      # @return [String] The lower tier model name.
+      def lower_tier_model
+        @lower_tier_model || 'internal-basic'
+      end
+
+      # Retrieves the model name designated for the middle tier (e.g., balanced performance).
+      # Defaults to 'internal-standard'.
+      # @return [String] The middle tier model name.
+      def middle_tier_model
+        @middle_tier_model || 'internal-standard'
+      end
+
+      # Retrieves the model name designated for the upper tier (e.g., most capable).
+      # Defaults to 'internal-premium'.
+      # @return [String] The upper tier model name.
+      def upper_tier_model
+        @upper_tier_model || 'internal-premium'
+      end
+    end
+  end
+end

data/lib/active_genie/data_extractor/basic.rb

@@ -43,7 +43,7 @@ module ActiveGenie::DataExtractor
       function = {
         name: 'data_extractor',
         description: 'Extract structured and typed data from user messages.',
-        schema: {
+        parameters: {
           type: "object",
           properties:,
           required: properties.keys

data/lib/active_genie/ranking/ranking.rb

@@ -72,7 +72,7 @@ module ActiveGenie::Ranking
     ELIMINATION_RELEGATION = 'relegation_tier'
     
     with_logging_context :log_context, ->(log) { 
-      @total_tokens += log[:total_tokens] if log[:code] == :llm_usage
+      @total_tokens += log[:total_tokens] || 0 if log[:code] == :llm_usage
     }
 
     def initial_log

data/lib/active_genie/scoring/basic.rb

@@ -48,7 +48,7 @@ module ActiveGenie::Scoring
       function = {
         name: 'scoring',
         description: 'Score the text based on the given criteria.',
-        schema: {
+        parameters: {
           type: "object",
           properties:,
           required: properties.keys

data/lib/active_genie/scoring/recommended_reviewers.rb

@@ -42,14 +42,15 @@ module ActiveGenie::Scoring
       function = {
         name: 'identify_reviewers',
         description: 'Discover reviewers based on the text and given criteria.',
-        schema: {
+        parameters: {
           type: "object",
           properties: {
             reasoning: { type: 'string' },
             reviewer1: { type: 'string' },
             reviewer2: { type: 'string' },
             reviewer3: { type: 'string' },
-          }
+          },
+          required: ['reasoning', 'reviewer1', 'reviewer2', 'reviewer3']
         }
       }
 

data/lib/tasks/templates/active_genie.rb

@@ -10,7 +10,7 @@ ActiveGenie.configure do |config|
   # config.providers.openai.client = ActiveGenie::Providers::Openai::Client.new(config)
 
   # example how add a new provider
-  # config.providers.register(:internal_company_api, InternalCompanyApi::Configuration)
+  # config.providers.register(InternalCompanyApi::Configuration)
 
   # Logs configuration
   # config.log_level = :debug # default is :info

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_genie
 version: !ruby/object:Gem::Version
-  version: 0.0.18
+  version: 0.0.20
 platform: ruby
 authors:
 - Radamés Roriz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-04-02 00:00:00.000000000 Z
+date: 2025-04-04 00:00:00.000000000 Z
 dependencies: []
 description: "# ActiveGenie \U0001F9DE‍♂️\n> The lodash for GenAI, stop reinventing
   the wheel\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/benchmark.yml/badge.svg)](https://github.com/roriz/active_genie/actions/workflows/benchmark.yml)\n\nActiveGenie
@@ -62,7 +62,7 @@ description: "# ActiveGenie \U0001F9DE‍♂️\n> The lodash for GenAI, stop re
   While Player 2 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\n*Recommended
-  model*: `gemini-2.0-flash-lite`\n\nFeatures:\n- Multi-reviewer evaluation with automatic
+  model*: `claude-3-5-haiku`\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###
@@ -93,9 +93,27 @@ description: "# ActiveGenie \U0001F9DE‍♂️\n> The lodash for GenAI, stop re
   `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.
+  for details.\n\n## How to create a new provider\n\nActiveGenie supports adding custom
+  providers to integrate with different LLM services. To create a new provider:\n\n1.
+  Create a configuration class for your provider in `lib/active_genie/configuration/providers/`:\n\n```ruby\n#
+  Example: lib/active_genie/configuration/providers/internal_company_api_config.rb\nmodule
+  ActiveGenie\n  module Configuration::Providers\n    class InternalCompanyApiConfig
+  < BaseConfig\n      NAME = :internal_company_api\n      \n      # API key accessor
+  with environment variable fallback\n      def api_key\n        @api_key || ENV['INTERNAL_COMPANY_API_KEY']\n
+  \     end\n      \n      # Base API URL\n      def api_url\n        @api_url ||
+  'https://api.internal-company.com/v1'\n      end\n      \n      # Client instantiation\n
+  \     def client\n        @client ||= ::ActiveGenie::Clients::InternalCompanyApiClient.new(self)\n
+  \     end\n      \n      # Model tier definitions\n      def lower_tier_model\n
+  \       @lower_tier_model || 'internal-basic'\n      end\n      \n      def middle_tier_model\n
+  \       @middle_tier_model || 'internal-standard'\n      end\n      \n      def
+  upper_tier_model\n        @upper_tier_model || 'internal-premium'\n      end\n    end\n
+  \ end\nend\n```\n\n2. Register your provider in your configuration:\n\n```ruby\n#
+  In config/initializers/active_genie.rb\nActiveGenie.configure do |config|\n  # Register
+  your custom provider\n  config.providers.register(InternalCompanyApi::Configuration)\n
+  \ \n  # Configure your provider\n  config.internal_company_api.api_key = ENV['INTERNAL_COMPANY_API_KEY']\nend\n```\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\n## License\n\nThis project is licensed under the Apache License
   2.0 License - see the [LICENSE](LICENSE) file for details.\n"
 email:
@@ -112,6 +130,7 @@ files:
 - lib/active_genie/battle/README.md
 - lib/active_genie/battle/basic.rb
 - lib/active_genie/clients/anthropic_client.rb
+- lib/active_genie/clients/base_client.rb
 - lib/active_genie/clients/google_client.rb
 - lib/active_genie/clients/helpers/retry.rb
 - lib/active_genie/clients/openai_client.rb
@@ -123,6 +142,7 @@ files:
 - lib/active_genie/configuration/providers/base_config.rb
 - lib/active_genie/configuration/providers/deepseek_config.rb
 - lib/active_genie/configuration/providers/google_config.rb
+- lib/active_genie/configuration/providers/internal_company_api_config.rb
 - lib/active_genie/configuration/providers/openai_config.rb
 - lib/active_genie/configuration/providers_config.rb
 - lib/active_genie/configuration/runtime_config.rb