active_genie 0.25.0 → 0.25.2

data/lib/active_genie/clients/providers/deepseek_client.rb

@@ -3,88 +3,95 @@
 require 'json'
 require 'net/http'
 
-require_relative './base_client'
+require_relative 'base_client'
 
 module ActiveGenie
   module Clients
     class DeepseekClient < BaseClient
-      class DeepseekError < ClientError; end
-      class RateLimitError < DeepseekError; end
       class InvalidResponseError < StandardError; end
 
-      # Requests structured JSON output from the DeepSeek model based on a schema.
+      # Requests structured JSON output from the Deepseek 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.
       # @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 = @config.llm.model || @config.providers.deepseek.tier_to_model(@config.llm.model_tier)
-
         payload = {
           messages:,
-          tools: [{
-            type: 'function',
-            function: {
-              **function,
-              parameters: {
-                **function[:parameters],
-                additionalProperties: false
-              },
-              strict: true
-            }.compact
-          }],
+          tools: [function_to_tool(function)],
           tool_choice: { type: 'function', function: { name: function[:name] } },
           stream: false,
           model:
         }
 
-        headers = {
-          'Authorization': "Bearer #{@config.providers.deepseek.api_key}"
-        }.compact
-
         retry_with_backoff do
-          response = request_deepseek(payload, headers)
+          response = request(payload)
 
-          parsed_response = JSON.parse(response.dig('choices', 0, 'message', 'tool_calls', 0, 'function', 'arguments'))
-          parsed_response = parsed_response['message'] || parsed_response
-
-          if parsed_response.nil? || parsed_response.keys.empty?
+          if response.nil? || response.keys.empty?
             raise InvalidResponseError,
-                  "Invalid response: #{parsed_response}"
+                  "Invalid response: #{response}"
           end
 
-          ActiveGenie::Logger.call({ code: :function_calling, payload:, parsed_response: })
+          ActiveGenie::Logger.call({ code: :function_calling, fine_tune: true, payload:, response: })
 
-          parsed_response
+          response
         end
       end
 
       private
 
-      # Make a request to the DeepSeek API
-      #
-      # @param payload [Hash] The request payload
-      # @param headers [Hash] Additional headers
-      # @return [Hash] The parsed response
-      def request_deepseek(payload, headers)
-        start_time = Time.now
-        url = "#{@config.providers.deepseek.api_url}/chat/completions"
-
+      def request(payload)
         response = post(url, payload, headers: headers)
+
         return nil if response.nil?
 
-        ActiveGenie::Logger.call({
-                                   code: :llm_usage,
-                                   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: response['usage']
-                                 })
-
-        response
+        ActiveGenie::Logger.call(
+          {
+            code: :llm_usage,
+            input_tokens: response.dig('usage', 'prompt_tokens'),
+            output_tokens: response.dig('usage', 'completion_tokens'),
+            total_tokens: response.dig('usage', 'total_tokens'),
+            model:,
+            usage: response['usage']
+          }
+        )
+
+        parsed_response = JSON.parse(response.dig('choices', 0, 'message', 'tool_calls', 0, 'function', 'arguments'))
+        parsed_response['message'] || parsed_response
+      end
+
+      def function_to_tool(function)
+        {
+          type: 'function',
+          function: {
+            **function,
+            parameters: {
+              **function[:parameters],
+              additionalProperties: false
+            },
+            strict: true
+          }.compact
+        }
+      end
+
+      def model
+        @config.llm.model || provider_config.tier_to_model(@config.llm.model_tier)
+      end
+
+      def url
+        "#{provider_config.api_url}/chat/completions"
+      end
+
+      def headers
+        {
+          Authorization: "Bearer #{provider_config.api_key}",
+          'Content-Type': 'application/json'
+        }.compact
+      end
+
+      def provider_config
+        @config.providers.deepseek
       end
     end
   end

data/lib/active_genie/clients/providers/google_client.rb

@@ -3,17 +3,12 @@
 require 'json'
 require 'net/http'
 require 'uri'
-require_relative './base_client'
+require_relative 'base_client'
 
 module ActiveGenie
   module 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'
-
       # 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.
@@ -22,81 +17,74 @@ module ActiveGenie
       # @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)
-        model = @config.llm.model || provider_config.tier_to_model(@config.llm.model_tier)
-
         contents = convert_messages_to_contents(messages, function)
         contents << output_as_json_schema(function)
 
         payload = {
-          contents: contents,
+          contents:,
           generationConfig: {
             response_mime_type: 'application/json',
             temperature: 0.1
           }
         }
-
-        endpoint = "#{API_VERSION_PATH}/#{model}:generateContent"
         params = { key: provider_config.api_key }
-        headers = DEFAULT_HEADERS
 
         retry_with_backoff do
-          start_time = Time.now
-          url = "#{provider_config.api_url}#{endpoint}"
-
-          response = post(url, payload, headers:, params:)
+          response = request(payload, params)
 
           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.call({
-                                       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.call({ 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
+          normalize_response(json_string)
         end
       end
 
-      def provider_config
-        @config.providers.google
-      end
+      API_VERSION_PATH = 'v1beta/models'
+      ROLE_TO_GOOGLE_ROLE = {
+        user: 'user',
+        assistant: 'model'
+      }.freeze
 
       private
 
-      def normalize_function_output(output)
-        output = if output.is_a?(Array)
-                   output.dig(0, 'properties') || output[0]
+      def request(payload, params)
+        response = post(url, payload, headers: DEFAULT_HEADERS, params:)
+
+        ActiveGenie::Logger.call(
+          {
+            code: :llm_usage,
+            input_tokens: response['usageMetadata']['promptTokenCount'] || 0,
+            output_tokens: response['usageMetadata']['candidatesTokenCount'] || 0,
+            total_tokens: response['usageMetadata']['totalTokenCount'] || (prompt_tokens + candidates_tokens),
+            model:,
+            usage: response['usageMetadata'] || {}
+          }
+        )
+
+        ActiveGenie::Logger.call(
+          {
+            code: :function_calling,
+            fine_tune: true,
+            payload:,
+            parsed_response: response&.dig('candidates', 0, 'content', 'parts', 0, 'text')
+          }
+        )
+
+        response
+      end
+
+      def normalize_response(json_string)
+        parsed_response = JSON.parse(json_string)
+
+        output = if parsed_response.is_a?(Array)
+                   parsed_response.dig(0, 'properties') || parsed_response[0]
                  else
-                   output
+                   parsed_response
                  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: '...' }
@@ -127,6 +115,18 @@ module ActiveGenie
           parts: [{ text: json_instruction }]
         }
       end
+
+      def model
+        @config.llm.model || provider_config.tier_to_model(@config.llm.model_tier)
+      end
+
+      def url
+        "#{provider_config.api_url}/#{API_VERSION_PATH}/#{model}:generateContent"
+      end
+
+      def provider_config
+        @config.providers.google
+      end
     end
   end
 end

data/lib/active_genie/clients/providers/openai_client.rb

@@ -3,13 +3,11 @@
 require 'json'
 require 'net/http'
 
-require_relative './base_client'
+require_relative 'base_client'
 
 module ActiveGenie
   module Clients
     class OpenaiClient < BaseClient
-      class OpenaiError < ClientError; end
-      class RateLimitError < OpenaiError; end
       class InvalidResponseError < StandardError; end
 
       # Requests structured JSON output from the OpenAI model based on a schema.
@@ -19,77 +17,78 @@ module ActiveGenie
       # @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)
-        model = @config.llm.model || provider_config.tier_to_model(@config.llm.model_tier)
-
         payload = {
           messages:,
-          tools: [{
-            type: 'function',
-            function: {
-              **function,
-              parameters: {
-                **function[:parameters],
-                additionalProperties: false
-              },
-              strict: true
-            }.compact
-          }],
+          tools: [function_to_tool(function)],
           tool_choice: { type: 'function', function: { name: function[:name] } },
           stream: false,
           model:
         }
 
-        headers = {
-          'Authorization': "Bearer #{provider_config.api_key}"
-        }.compact
-
         retry_with_backoff do
-          response = request_openai(payload, headers)
+          response = request(payload)
 
-          parsed_response = JSON.parse(response.dig('choices', 0, 'message', 'tool_calls', 0, 'function', 'arguments'))
-          parsed_response = parsed_response['message'] || parsed_response
+          raise InvalidResponseError, "Invalid response: #{response}" if response.nil? || response.keys.empty?
 
-          if parsed_response.nil? || parsed_response.keys.empty?
-            raise InvalidResponseError,
-                  "Invalid response: #{parsed_response}"
-          end
+          ActiveGenie::Logger.call({ code: :function_calling, fine_tune: true, payload:, response: })
 
-          ActiveGenie::Logger.call({ code: :function_calling, payload:, parsed_response: })
-
-          parsed_response
+          response
         end
       end
 
-      def provider_config
-        @config.providers.openai
-      end
-
       private
 
-      # Make a request to the OpenAI API
-      #
-      # @param payload [Hash] The request payload
-      # @param headers [Hash] Additional headers
-      # @return [Hash] The parsed response
-      def request_openai(payload, headers)
-        start_time = Time.now
-        url = "#{provider_config.api_url}/chat/completions"
-
+      def request(payload)
         response = post(url, payload, headers: headers)
 
         return nil if response.nil?
 
-        ActiveGenie::Logger.call({
-                                   code: :llm_usage,
-                                   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: response['usage']
-                                 })
-
-        response
+        ActiveGenie::Logger.call(
+          {
+            code: :llm_usage,
+            input_tokens: response.dig('usage', 'prompt_tokens'),
+            output_tokens: response.dig('usage', 'completion_tokens'),
+            total_tokens: response.dig('usage', 'total_tokens'),
+            model:,
+            usage: response['usage']
+          }
+        )
+
+        parsed_response = JSON.parse(response.dig('choices', 0, 'message', 'tool_calls', 0, 'function', 'arguments'))
+        parsed_response['message'] || parsed_response
+      end
+
+      def function_to_tool(function)
+        {
+          type: 'function',
+          function: {
+            **function,
+            parameters: {
+              **function[:parameters],
+              additionalProperties: false
+            },
+            strict: true
+          }.compact
+        }
+      end
+
+      def model
+        @config.llm.model || provider_config.tier_to_model(@config.llm.model_tier)
+      end
+
+      def url
+        "#{provider_config.api_url}/chat/completions"
+      end
+
+      def headers
+        {
+          Authorization: "Bearer #{provider_config.api_key}",
+          'Content-Type': 'application/json'
+        }.compact
+      end
+
+      def provider_config
+        @config.providers.openai
       end
     end
   end

data/lib/active_genie/clients/unified_client.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require_relative './providers/openai_client'
-require_relative './providers/anthropic_client'
-require_relative './providers/google_client'
-require_relative './providers/deepseek_client'
+require_relative 'providers/openai_client'
+require_relative 'providers/anthropic_client'
+require_relative 'providers/google_client'
+require_relative 'providers/deepseek_client'
 require_relative '../errors/invalid_provider_error'
 
 module ActiveGenie
@@ -38,7 +38,8 @@ module ActiveGenie
 
         def normalize_response(response)
           response.each do |key, value|
-            response[key] = nil if ['null', 'none', 'undefined', '', 'unknown', '<unknown>'].include?(value.to_s.strip.downcase)
+            response[key] = nil if ['null', 'none', 'undefined', '', 'unknown',
+                                    '<unknown>'].include?(value.to_s.strip.downcase)
           end
 
           response

data/lib/active_genie/config/battle_config.rb

@@ -2,7 +2,9 @@
 
 module ActiveGenie
   module Config
+    # rubocop:disable Lint/EmptyClass
     class BattleConfig
     end
+    # rubocop:enable Lint/EmptyClass
   end
 end

data/lib/active_genie/config/data_extractor_config.rb

@@ -13,9 +13,9 @@ module ActiveGenie
 
       def merge(config_params = {})
         dup.tap do |config|
-          config.with_explanation = config_params[:with_explanation] if config_params[:with_explanation]
-          config.min_accuracy = config_params[:min_accuracy] if config_params[:min_accuracy]
-          config.verbose = config_params[:verbose] if config_params[:verbose]
+          config.with_explanation = config_params[:with_explanation] if config_params.key?(:with_explanation)
+          config.min_accuracy = config_params[:min_accuracy] if config_params.key?(:min_accuracy)
+          config.verbose = config_params[:verbose] if config_params.key?(:verbose)
         end
       end
     end

data/lib/active_genie/config/llm_config.rb

@@ -21,7 +21,9 @@ module ActiveGenie
       end
 
       def provider=(provider)
-        @provider = provider&.to_s&.downcase&.strip&.to_sym
+        return if provider.nil? || provider.empty?
+
+        @provider = provider.to_s.downcase.strip.to_sym
       end
 
       def merge(config_params = {})

data/lib/active_genie/config/log_config.rb

@@ -3,10 +3,42 @@
 module ActiveGenie
   module Config
     class LogConfig
+      attr_writer :file_path, :fine_tune_file_path
+
+      def file_path
+        @file_path || 'log/active_genie.log'
+      end
+
+      def fine_tune_file_path
+        @fine_tune_file_path || 'log/active_genie_fine_tune.log'
+      end
+
+      def output
+        @output || ->(log) { $stdout.puts log }
+      end
+
+      def output=(output)
+        raise InvalidLogOutputError, output unless output.respond_to?(:call)
+
+        @output = output
+      end
+
+      def output_call(log)
+        output.call(log)
+
+        Array(@observers).each do |obs|
+          next unless obs[:scope].all? { |key, value| log[key.to_sym] == value }
+
+          obs[:observer].call(log)
+        rescue StandardError => e
+          ActiveGenie::Logger.call(code: :observer_error, **obs, error: e.message)
+        end
+      end
+
       def add_observer(observers: [], scope: nil, &block)
         @observers ||= []
 
-        raise ArgumentError, 'Scope must be a hash' if !scope.nil? && !scope.is_a?(Hash)
+        raise ArgumentError, 'Scope must be a hash' unless scope.is_a?(Hash)
 
         @observers << { observer: block, scope: scope || {} } if block_given?
         Array(observers).each do |observer|
@@ -24,16 +56,6 @@ module ActiveGenie
         @observers = []
       end
 
-      def call_observers(log)
-        Array(@observers).each do |obs|
-          next unless obs[:scope].all? { |key, value| log[key.to_sym] == value }
-
-          obs[:observer].call(log)
-        rescue StandardError => e
-          ActiveGenie::Logger.call(code: :observer_error, **obs, error: e.message)
-        end
-      end
-
       def merge(config_params = {})
         dup.tap do |config|
           config.add_observer(config_params[:observers]) if config_params[:observers]

data/lib/active_genie/config/providers/anthropic_config.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative './provider_base'
+require_relative 'provider_base'
 
 module ActiveGenie
   module Config
@@ -14,7 +14,7 @@ module ActiveGenie
         # Falls back to the ANTHROPIC_API_KEY environment variable if not set.
         # @return [String, nil] The API key.
         def api_key
-          @api_key || ENV['ANTHROPIC_API_KEY']
+          @api_key || ENV.fetch('ANTHROPIC_API_KEY', nil)
         end
 
         # Retrieves the base API URL for Anthropic API.

data/lib/active_genie/config/providers/deepseek_config.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative './provider_base'
+require_relative 'provider_base'
 
 module ActiveGenie
   module Config
@@ -14,7 +14,7 @@ module ActiveGenie
         # Falls back to the DEEPSEEK_API_KEY environment variable if not set.
         # @return [String, nil] The API key.
         def api_key
-          @api_key || ENV['DEEPSEEK_API_KEY']
+          @api_key || ENV.fetch('DEEPSEEK_API_KEY', nil)
         end
 
         # Retrieves the base API URL for DeepSeek API.

data/lib/active_genie/config/providers/google_config.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative './provider_base'
+require_relative 'provider_base'
 
 module ActiveGenie
   module Config
@@ -14,7 +14,7 @@ module ActiveGenie
         # Falls back to the GENERATIVE_LANGUAGE_GOOGLE_API_KEY environment variable if not set.
         # @return [String, nil] The API key.
         def api_key
-          @api_key || ENV['GENERATIVE_LANGUAGE_GOOGLE_API_KEY'] || ENV['GEMINI_API_KEY']
+          @api_key || ENV['GENERATIVE_LANGUAGE_GOOGLE_API_KEY'] || ENV.fetch('GEMINI_API_KEY', nil)
         end
 
         # Retrieves the base API URL for Google Generative Language API.

data/lib/active_genie/config/providers/openai_config.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative './provider_base'
+require_relative 'provider_base'
 
 module ActiveGenie
   module Config
@@ -14,7 +14,7 @@ module ActiveGenie
         # Falls back to the OPENAI_API_KEY environment variable if not set.
         # @return [String, nil] The API key.
         def api_key
-          @api_key || ENV['OPENAI_API_KEY']
+          @api_key || ENV.fetch('OPENAI_API_KEY', nil)
         end
 
         # Retrieves the base API URL for OpenAI API.

data/lib/active_genie/config/providers_config.rb

@@ -16,7 +16,7 @@ module ActiveGenie
 
       def default=(provider)
         normalized_provider = provider.to_s.downcase.strip
-        @default = normalized_provider.size > 0 ? normalized_provider : valid.keys.first
+        @default = normalized_provider.size.positive? ? normalized_provider : valid.keys.first
       end
 
       def valid
@@ -47,15 +47,16 @@ module ActiveGenie
       def merge(config_params = {})
         dup.tap do |config|
           config.add(config_params[:providers]) if config_params[:providers]
+          config.default = config_params[:default] if config_params[:default]
         end
       end
 
-      def method_missing(m, *args, &block)
-        @all[m] || super
+      def method_missing(method_name, *args, &)
+        @all[method_name] || super
       end
 
-      def respond_to_missing?(m, include_private = false)
-        @all.key?(m) || super
+      def respond_to_missing?(method_name, include_private = false)
+        @all.key?(method_name) || super
       end
     end
   end