active_genie 0.30.1 → 0.30.8

data/lib/active_genie/lister/feud.json

@@ -8,6 +8,10 @@
         "type": "string",
         "description": "The theme for the feud."
       },
+      "why_these_items": {
+        "type": "string",
+        "description": "Explanation of why these items were chosen."
+      },
       "items": {
         "type": "array",
         "description": "The list of items for the feud.",
@@ -16,6 +20,6 @@
         }
       }
     },
-    "required": ["theme", "items"]
+    "required": ["theme", "why_these_items", "items"]
   }
 }

data/lib/active_genie/lister/feud.rb

@@ -9,17 +9,13 @@ module ActiveGenie
     # @example Feud usage with two players and criteria
     #   Feud.call("Industries that are most likely to be affected by climate change")
     #
-    class Feud
-      def self.call(...)
-        new(...).call
-      end
-
+    class Feud < ActiveGenie::BaseModule
       # @param theme [String] The theme for the feud
       # @param config [Hash] Additional configuration options
       # @return [Array of strings] List of items
       def initialize(theme, config: {})
         @theme = theme
-        @config = ActiveGenie.configuration.merge(config)
+        super(config:)
       end
 
       # @return [Array of strings] The list of items
@@ -30,14 +26,17 @@ module ActiveGenie
           {  role: 'user', content: "theme: #{@theme}" }
         ]
 
-        response = ::ActiveGenie::Providers::UnifiedProvider.function_calling(
+        provider_response = ::ActiveGenie::Providers::UnifiedProvider.function_calling(
           messages,
           FUNCTION,
-          config: @config
+          config:
         )
 
-        log_feud(response)
-        response['items'] || []
+        ActiveGenie::Result.new(
+          data: provider_response['items'] || [],
+          reasoning: provider_response['why_these_items'],
+          metadata: provider_response
+        )
       end
 
       PROMPT = File.read(File.join(__dir__, 'feud.prompt.md'))
@@ -46,15 +45,11 @@ module ActiveGenie
       private
 
       def number_of_items
-        @config.lister.number_of_items
+        config.lister.number_of_items
       end
 
-      def log_feud(response)
-        @config.logger.call(
-          code: :feud,
-          theme: @theme[0..30],
-          items: response['items'].map { |item| item[0..30] }
-        )
+      def module_config
+        { llm: { recommended_model: 'claude-haiku-4-5' } }
       end
     end
   end

data/lib/active_genie/lister/juries.rb

@@ -14,14 +14,9 @@ module ActiveGenie
     # @example Getting jury for technical content
     #   Juries.call("Technical documentation about API design",
     #                           "Evaluate technical accuracy and clarity")
-    #   # => { jury1: "API Architect", jury2: "Technical Writer",
-    #   #      jury3: "Developer Advocate", reasoning: "..." }
+    #   # => [ "API Architect", "Technical Writer", "Developer Advocate" ]
     #
-    class Juries
-      def self.call(...)
-        new(...).call
-      end
-
+    class Juries < ActiveGenie::BaseModule
       # Initializes a new jury recommendation instance
       #
       # @param text [String] The text content to analyze for jury recommendations
@@ -30,7 +25,7 @@ module ActiveGenie
       def initialize(text, criteria, config: {})
         @text = text
         @criteria = criteria
-        @config = ActiveGenie.configuration.merge(config)
+        super(config:)
       end
 
       def call
@@ -46,7 +41,10 @@ module ActiveGenie
           parameters: {
             type: 'object',
             properties: {
-              reasoning: { type: 'string' },
+              why_these_juries: {
+                type: 'string',
+                description: 'A brief explanation of why these juries were chosen.'
+              },
               juries: {
                 type: 'array',
                 description: 'The list of best juries',
@@ -59,24 +57,28 @@ module ActiveGenie
           }
         }
 
-        result = client.function_calling(
+        provider_response = ::ActiveGenie::Providers::UnifiedProvider.function_calling(
           messages,
           function,
-          config: @config
+          config:
         )
 
-        result['juries'] || []
+        ActiveGenie::Result.new(
+          data: provider_response['juries'] || [],
+          reasoning: provider_response['why_these_juries'],
+          metadata: provider_response
+        )
       end
 
       private
 
-      def client
-        ::ActiveGenie::Providers::UnifiedProvider
-      end
-
       def prompt
         @prompt ||= File.read(File.join(__dir__, 'juries.prompt.md'))
       end
+
+      def module_config
+        { llm: { recommended_model: 'deepseek-chat' } }
+      end
     end
   end
 end

data/lib/active_genie/logger.rb

@@ -5,32 +5,24 @@ require 'fileutils'
 
 module ActiveGenie
   class Logger
-    def initialize(log_config: nil)
-      @log_config = log_config || ActiveGenie.configuration.log
-    end
-
-    def call(data)
-      log = data.merge(@log_config.additional_context)
+    def call(data, config:)
+      log = data.merge(config.log.additional_context || {})
                 .merge(
                   timestamp: Time.now,
                   process_id: Process.pid
                 )
 
-      persist!(log)
-      output_call(log)
-      call_observers(log)
+      persist!(log, config:)
+      output_call(log, config:)
+      call_observers(log, config:)
 
       log
     end
 
-    def merge(log_config = nil)
-      new(log_config:)
-    end
-
     private
 
-    def call_observers(log)
-      Array(@log_config.observers).each do |observer|
+    def call_observers(log, config:)
+      Array(config.log.observers).each do |observer|
         next unless observer[:scope].all? { |key, value| log[key.to_sym] == value }
 
         observer[:observer]&.call(log)
@@ -39,9 +31,9 @@ module ActiveGenie
       end
     end
 
-    def output_call(log)
-      if @log_config.output
-        @log_config.output&.call(log)
+    def output_call(log, config:)
+      if config.log.output
+        config.log.output&.call(log)
       else
         $stdout.puts log
       end
@@ -49,20 +41,16 @@ module ActiveGenie
       call(code: :output_error, error: e.message)
     end
 
-    def persist!(log)
-      file_path = log_to_file_path(log)
+    def persist!(log, config:)
+      file_path = if log.key?(:fine_tune) && log[:fine_tune]
+                    config.log.fine_tune_file_path
+                  else
+                    config.log.file_path
+                  end
       folder_path = File.dirname(file_path)
 
       FileUtils.mkdir_p(folder_path)
       File.write(file_path, "#{JSON.generate(log)}\n", mode: 'a')
     end
-
-    def log_to_file_path(log)
-      if log.key?(:fine_tune) && log[:fine_tune]
-        @log_config.fine_tune_file_path
-      else
-        @log_config.file_path
-      end
-    end
   end
 end

data/lib/active_genie/providers/anthropic_provider.rb

@@ -30,7 +30,11 @@ module ActiveGenie
           temperature: @config.llm.temperature || 0
         }
 
-        request(payload).dig('content', 0, 'input')
+        response = retry_with_backoff do
+          request(payload)
+        end
+
+        response.dig('content', 0, 'input')
       end
 
       ANTHROPIC_ENDPOINT = '/v1/messages'
@@ -55,7 +59,7 @@ module ActiveGenie
       def request(payload)
         response = post(url, payload, headers:)
 
-        @config.logger.call(
+        ActiveGenie.logger.call(
           {
             code: :llm_usage,
             input_tokens: response.dig('usage', 'input_tokens'),
@@ -65,15 +69,17 @@ module ActiveGenie
                                                                       'output_tokens'),
             model: payload[:model],
             usage: response['usage']
-          }
+          },
+          config: @config
         )
-        @config.logger.call(
+        ActiveGenie.logger.call(
           {
             code: :function_calling,
             fine_tune: true,
             payload:,
             parsed_response: response.dig('content', 0, 'input')
-          }
+          },
+          config: @config
         )
 
         response
@@ -84,7 +90,7 @@ module ActiveGenie
       end
 
       def model
-        @config.llm.model || @config.providers.anthropic.tier_to_model(@config.llm.model_tier)
+        @config.llm.model
       end
 
       def headers

data/lib/active_genie/providers/base_provider.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 require 'net/http'
+require_relative '../errors/provider_server_error'
 
 module ActiveGenie
   module Providers
     class BaseProvider
       class ProviderUnknownError < StandardError; end
-      class ProviderServerError < StandardError; end
 
       DEFAULT_HEADERS = {
         'Content-Type': 'application/json',
@@ -104,9 +104,7 @@ module ActiveGenie
         http.read_timeout = @config.llm.read_timeout || DEFAULT_TIMEOUT
         http.open_timeout = @config.llm.open_timeout || DEFAULT_OPEN_TIMEOUT
 
-        retry_with_backoff do
-          http.request(request)
-        end
+        http.request(request)
       end
 
       # Apply headers to the request
@@ -154,7 +152,7 @@ module ActiveGenie
       #
       # @param details [Hash] Request and response details
       def log_request_details(uri:, request:, response:, start_time:, parsed_response:)
-        @config.logger.call(
+        ActiveGenie.logger.call(
           {
             code: :http_request,
             uri: uri.to_s,
@@ -162,7 +160,7 @@ module ActiveGenie
             status: response.code,
             duration: Time.now - start_time,
             response_size: parsed_response.to_s.bytesize
-          }
+          }, config: @config
         )
       end
 
@@ -172,23 +170,22 @@ module ActiveGenie
         retries = 0
 
         begin
-          response = yield
-
-          raise ProviderServerError, "Provider server error: #{response.code} - #{response.body}" if !response.is_a?(Net::HTTPSuccess) && response.code.to_i >= 500
-
-          response
-        rescue Net::OpenTimeout, Net::ReadTimeout, Errno::ECONNREFUSED, ProviderServerError => e
+          yield
+        rescue Net::OpenTimeout, Net::ReadTimeout, Errno::ECONNREFUSED, ActiveGenie::ProviderServerError,
+               JSON::ParserError => e
           raise if retries > max_retries
 
           sleep_time = retry_delay * (2**retries)
           retries += 1
 
-          @config.logger.call(
-            code: :retry_attempt,
-            attempt: retries,
-            max_retries: max_retries,
-            delay: sleep_time,
-            error: e.message
+          ActiveGenie.logger.call(
+            {
+              code: :retry_attempt,
+              attempt: retries,
+              max_retries:,
+              next_retry_in_seconds: sleep_time,
+              error: e.message
+            }, config: @config
           )
 
           sleep(sleep_time)

data/lib/active_genie/providers/deepseek_provider.rb

@@ -25,14 +25,14 @@ module ActiveGenie
           model:
         }
 
-        response = request(payload)
-
-        if response.nil? || response.keys.empty?
-          raise InvalidResponseError,
-                "Invalid response: #{response}"
+        response = retry_with_backoff do
+          request(payload)
         end
 
-        @config.logger.call({ code: :function_calling, fine_tune: true, payload:, response: })
+        raise InvalidResponseError, "Invalid response: #{response}" if response.keys.empty?
+        raise InvalidResponseError, 'Invalid response: empty' if response.nil?
+
+        ActiveGenie.logger.call({ code: :function_calling, fine_tune: true, payload:, response: }, config: @config)
 
         response
       end
@@ -44,7 +44,7 @@ module ActiveGenie
 
         return nil if response.nil?
 
-        @config.logger.call(
+        ActiveGenie.logger.call(
           {
             code: :llm_usage,
             input_tokens: response.dig('usage', 'prompt_tokens'),
@@ -52,11 +52,19 @@ module ActiveGenie
             total_tokens: response.dig('usage', 'total_tokens'),
             model:,
             usage: response['usage']
-          }
+          }, config: @config
         )
 
-        parsed_response = JSON.parse(response.dig('choices', 0, 'message', 'tool_calls', 0, 'function', 'arguments'))
+        parsed_response = JSON.parse(get_response_body(response))
         parsed_response['message'] || parsed_response
+      rescue JSON::ParserError
+        raise InvalidResponseError, "Invalid response: #{get_response_body(response)}"
+      end
+
+      def get_response_body(response)
+        response.dig('choices', 0, 'message', 'tool_calls', 0, 'function', 'arguments')
+                .gsub(', " "', '')
+                .strip
       end
 
       def function_to_tool(function)
@@ -74,7 +82,7 @@ module ActiveGenie
       end
 
       def model
-        @config.llm.model || provider_config.tier_to_model(@config.llm.model_tier)
+        @config.llm.model
       end
 
       def url

data/lib/active_genie/providers/google_provider.rb

@@ -29,12 +29,17 @@ module ActiveGenie
         }
         params = { key: provider_config.api_key }
 
-        response = request(payload, params)
+        response = retry_with_backoff do
+          request(payload, params)
+        end
 
         json_string = response&.dig('candidates', 0, 'content', 'parts', 0, 'text')
         return nil if json_string.nil? || json_string.empty?
 
-        @config.logger.call({ code: :function_calling, fine_tune: true, payload:, parsed_response: json_string })
+        ActiveGenie.logger.call(
+          { code: :function_calling, fine_tune: true, payload:, parsed_response: json_string },
+          config: @config
+        )
 
         normalize_response(json_string)
       end
@@ -50,7 +55,7 @@ module ActiveGenie
       def request(payload, params)
         response = post(url, payload, headers: DEFAULT_HEADERS, params:)
 
-        @config.logger.call(
+        ActiveGenie.logger.call(
           {
             code: :llm_usage,
             input_tokens: response['usageMetadata']['promptTokenCount'] || 0,
@@ -58,7 +63,8 @@ module ActiveGenie
             total_tokens: response['usageMetadata']['totalTokenCount'] || (prompt_tokens + candidates_tokens),
             model:,
             usage: response['usageMetadata'] || {}
-          }
+          },
+          config: @config
         )
 
         response
@@ -108,7 +114,7 @@ module ActiveGenie
       end
 
       def model
-        @config.llm.model || provider_config.tier_to_model(@config.llm.model_tier)
+        @config.llm.model
       end
 
       def url

data/lib/active_genie/providers/openai_provider.rb

@@ -25,11 +25,13 @@ module ActiveGenie
           model:
         }
 
-        response = request(payload)
+        response = retry_with_backoff do
+          request(payload)
+        end
 
         raise InvalidResponseError, "Invalid response: #{response}" if response.nil? || response.keys.empty?
 
-        @config.logger.call({ code: :function_calling, fine_tune: true, payload:, response: })
+        ActiveGenie.logger.call({ code: :function_calling, fine_tune: true, payload:, response: }, config: @config)
 
         response
       end
@@ -37,11 +39,11 @@ module ActiveGenie
       private
 
       def request(payload)
-        response = post(url, payload, headers: headers)
+        response = post(url, payload, headers:)
 
         return nil if response.nil?
 
-        @config.logger.call(
+        ActiveGenie.logger.call(
           {
             code: :llm_usage,
             input_tokens: response.dig('usage', 'prompt_tokens'),
@@ -49,7 +51,7 @@ module ActiveGenie
             total_tokens: response.dig('usage', 'total_tokens'),
             model:,
             usage: response['usage']
-          }
+          }, config: @config
         )
 
         parsed_response = JSON.parse(response.dig('choices', 0, 'message', 'tool_calls', 0, 'function', 'arguments'))
@@ -71,7 +73,7 @@ module ActiveGenie
       end
 
       def model
-        @config.llm.model || provider_config.tier_to_model(@config.llm.model_tier)
+        @config.llm.model
       end
 
       def url

data/lib/active_genie/providers/unified_provider.rb

@@ -5,6 +5,8 @@ require_relative 'anthropic_provider'
 require_relative 'google_provider'
 require_relative 'deepseek_provider'
 require_relative '../errors/invalid_provider_error'
+require_relative '../errors/invalid_model_error'
+require_relative '../errors/without_available_provider_error'
 
 module ActiveGenie
   module Providers
@@ -18,10 +20,13 @@ module ActiveGenie
         }.freeze
 
         def function_calling(messages, function, config: {})
-          provider_name = config.llm.provider_name || config.providers.default
-          provider = PROVIDER_NAME_TO_PROVIDER[provider_name.to_sym]
+          model, provider_name = model_and_provider_by(config)
 
-          raise ActiveGenie::InvalidProviderError, provider_name if provider.nil?
+          provider = PROVIDER_NAME_TO_PROVIDER[provider_name&.to_sym]
+
+          raise ActiveGenie::WithoutAvailableProviderError if provider.nil?
+
+          config.llm.model = model
 
           response = provider.new(config).function_calling(messages, function)
 
@@ -30,6 +35,56 @@ module ActiveGenie
 
         private
 
+        # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+        def model_and_provider_by(config)
+          model, provider_name = explicit_choice(config)
+          model, provider_name = global_default(config) if model.nil? && provider_name.nil?
+          model, provider_name = module_recommendation(config) if model.nil? && provider_name.nil?
+
+          model, provider_name = infer_from_partial(config, model, provider_name) if model.nil? || provider_name.nil?
+          model, provider_name = any_available(config) if model.nil? || provider_name.nil?
+
+          [model, provider_name]
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+
+        def explicit_choice(config)
+          model = config.llm.model
+          provider_name = config.providers.default
+
+          [model, provider_name]
+        end
+
+        def global_default(config)
+          provider_name = config.providers.default
+
+          [nil, provider_name]
+        end
+
+        def module_recommendation(config)
+          model = config.llm.recommended_model
+          provider_name = config.providers.provider_name_by_model(model) if model
+
+          return nil if model.nil? || provider_name.nil?
+
+          [model, provider_name]
+        end
+
+        def infer_from_partial(config, model, provider_name)
+          provider_name ||= config.providers.provider_name_by_model(model) if model
+          model ||= config.providers.valid[provider_name.to_sym]&.default_model if provider_name
+
+          [model, provider_name]
+        end
+
+        def any_available(config)
+          provider = config.providers.valid.first
+          provider_name = provider&.first
+          model = provider&.last&.default_model
+
+          [model, provider_name]
+        end
+
         def normalize_response(response)
           response.each do |key, value|
             response[key] = nil if ['null', 'none', 'undefined', '', 'unknown',