[WIP] Refactor Provider Options

Author: sirwolfgang

lib/active_agent/generation_provider/_base_provider.rb

@@ -36,18 +36,18 @@ class GenerationProviderError < StandardError; end
       attr_reader :client, :config, :prompt, :response, :access_token, :model_name
 
       def initialize(config)
-        @config = config
-        @prompt = nil
-        @response = nil
+        @config     = config
+        @prompt     = nil
+        @response   = nil
         @model_name = config["model"] if config
       end
 
       def generate(prompt)
         raise NotImplementedError, "Subclasses must implement the 'generate' method"
       end
 
+      # Optional embedding support - override in providers that support it
       def embed(prompt)
-        # Optional embedding support - override in providers that support it
         raise NotImplementedError, "#{self.class.name} does not support embeddings"
       end
 

lib/active_agent/generation_provider/anthropic_provider.rb

@@ -11,6 +11,8 @@ class AnthropicProvider < BaseProvider
       include MessageFormatting
       include ToolManagement
 
+      attr_reader :access_token
+
       def initialize(config)
         super
         @access_token ||= config["api_key"] || config["access_token"] || Anthropic.configuration.access_token || ENV["ANTHROPIC_ACCESS_TOKEN"]

lib/active_agent/generation_provider/common/options.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  module GenerationProvider
+    module Common
+      class Options
+        include ActiveModel::Model
+        include ActiveModel::Attributes
+
+        def self.delegate_attributes(*attributes, to:)
+          attributes.each do |attribute|
+            define_method(attribute) do
+              public_send(to)&.public_send(attribute)
+            end
+
+            define_method("#{attribute}=") do |value|
+              if public_send(to).nil?
+                public_send("#{to}=", {})
+              end
+
+              public_send(to).public_send("#{attribute}=", value)
+            end
+          end
+        end
+
+          def deep_compact(hash = nil, **kwargs)
+            (hash || kwargs).each_with_object({}) do |(key, value), result|
+              compacted_value = case value
+              when Hash
+                deep_compacted = deep_compact(value)
+                deep_compacted unless deep_compacted.empty?
+              when Array
+                compacted_array = value.map { |v| v.is_a?(Hash) ? deep_compact(v) : v }.compact
+                compacted_array unless compacted_array.empty?
+              else
+                value
+              end
+
+              result[key] = compacted_value unless compacted_value.nil?
+            end
+          end
+      end
+    end
+  end
+end

lib/active_agent/generation_provider/ollama/options.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "../open_ai/options"
+
+module ActiveAgent
+  module GenerationProvider
+    module Ollama
+      class Options < ActiveAgent::GenerationProvider::OpenAI::Options
+        # Client Options
+        attribute :uri_base, :string, default: "http://localhost:11434"
+
+        private
+
+        def resolve_access_token(settings)
+          settings["api_key"] ||
+            settings["access_token"] ||
+            ENV["OLLAMA_API_KEY"] ||
+            ENV["OLLAMA_ACCESS_TOKEN"]
+        end
+
+        # Not Used as Part of Ollama
+        def resolve_organization_id(settings) = nil
+        def resolve_admin_token(settings)     = nil
+      end
+    end
+  end
+end

lib/active_agent/generation_provider/ollama_provider.rb

@@ -3,21 +3,16 @@
 require_gem!(:openai, __FILE__)
 
 require_relative "open_ai_provider"
+require_relative "ollama/options"
 
 module ActiveAgent
   module GenerationProvider
     class OllamaProvider < OpenAIProvider
-      def initialize(config)
-        @config = config
-        @access_token ||= config["api_key"] || config["access_token"] || ENV["OLLAMA_API_KEY"] || ENV["OLLAMA_ACCESS_TOKEN"]
-        @model_name = config["model"]
-        @host = config["host"] || "http://localhost:11434"
-        @api_version = config["api_version"] || "v1"
-        @client = OpenAI::Client.new(uri_base: @host, access_token: @access_token, log_errors: Rails.env.development?, api_version: @api_version)
-      end
 
       protected
 
+      def namespace = Ollama
+
       def format_error_message(error)
         # Check for various connection-related errors
         connection_errors = [

lib/active_agent/generation_provider/open_ai/options.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require_relative "../common/options"
+
+module ActiveAgent
+  module GenerationProvider
+    module OpenAI
+      class Options < Common::Options
+        # Client Options
+        attribute :access_token,    :string
+        attribute :uri_base,        :string
+        attribute :request_timeout, :integer
+        attribute :organization_id, :string
+        attribute :admin_token,     :string
+
+        # Prompting Options
+        attribute :model,           :string,  default: "gpt-4o-mini"
+        attribute :temperature,     :float,   default: 0.7
+        attribute :stream,          :boolean, default: false
+
+        validates :model, presence: true
+        validates :temperature, numericality: { greater_than_or_equal_to: 0, less_than_or_equal_to: 2 }, allow_nil: true
+        validates :access_token, presence: true, if: :require_access_token?
+
+        # Backwards Compatibility
+        alias_attribute :host, :uri_base
+        alias_attribute :api_key, :access_token
+        alias_attribute :model_name, :model
+
+        # Initialize from a hash (settings) with fallback to environment variables and OpenAI gem configuration
+        def initialize(**settings)
+          settings = settings.deep_symbolize_keys if settings.respond_to?(:deep_symbolize_keys)
+
+          super(**deep_compact(settings.except(:default_url_options).merge(
+            access_token:    settings[:access_token]    || resolve_access_token(settings),
+            organization_id: settings[:organization_id] || resolve_organization_id(settings),
+            admin_token:     settings[:admin_token]     || resolve_admin_token(settings),
+          )))
+        end
+
+        # Returns a hash suitable for OpenAI::Client initialization
+        def client_options
+          deep_compact(
+            access_token:,
+            uri_base:,
+            organization_id:,
+            extra_headers: client_options_extra_headers,
+            log_errors: true
+          )
+        end
+
+        # Returns parameters for chat completion requests
+        def chat_parameters
+          deep_compact(
+            model:,
+            temperature:
+          )
+        end
+
+        # Convert to hash for compatibility with existing code
+        def to_h
+          deep_compact(
+            "host"            => host,
+            "api_key"         => api_key,
+            "access_token"    => access_token,
+            "organization_id" => organization_id,
+            "admin_token"     => admin_token,
+            "model"           => model,
+            "temperature"     => temperature,
+            "stream"          => stream
+          )
+        end
+
+        alias_method :to_hash, :to_h
+
+        protected
+
+        def client_options_extra_headers = nil
+
+        private
+
+        def resolve_access_token(settings)
+          settings[:api_key] ||
+            openai_settings_access_token ||
+            ENV["OPENAI_ACCESS_TOKEN"]
+        end
+
+        def resolve_organization_id(settings)
+            openai_settings_organization_id ||
+            ENV["OPENAI_ORGANIZATION_ID"]
+        end
+
+        def resolve_admin_token(settings)
+            openai_settings_admin_token ||
+            ENV["OPENAI_ADMIN_TOKEN"]
+        end
+
+        def openai_settings_access_token
+          return nil unless defined?(::OpenAI)
+          ::OpenAI.configuration.access_token
+        rescue
+          nil
+        end
+
+        def openai_settings_organization_id
+          return nil unless defined?(::OpenAI)
+          ::OpenAI.configuration.organization_id
+        rescue
+          nil
+        end
+
+        def openai_settings_admin_token
+          return nil unless defined?(::OpenAI)
+          ::OpenAI.configuration.admin_token
+        rescue
+          nil
+        end
+
+        # Only require access token if no other authentication method is available
+        def require_access_token?
+          resolved_access_token.blank?
+        end
+      end
+    end
+  end
+end

lib/active_agent/generation_provider/open_ai_provider.rb

@@ -1,4 +1,5 @@
 require_relative "_base_provider"
+require_relative "open_ai/options"
 
 require_gem!(:openai, __FILE__)
 
@@ -9,21 +10,20 @@ class OpenAIProvider < BaseProvider
       include MessageFormatting
       include ToolManagement
 
-      def initialize(config)
+      attr_reader :options
+
+      def initialize(options)
         super
-        @host = config["host"] || nil
-        @access_token ||= config["api_key"] || config["access_token"] || OpenAI.configuration.access_token || ENV["OPENAI_ACCESS_TOKEN"]
-        @organization_id = config["organization_id"] || OpenAI.configuration.organization_id || ENV["OPENAI_ORGANIZATION_ID"]
-        @admin_token = config["admin_token"] || OpenAI.configuration.admin_token || ENV["OPENAI_ADMIN_TOKEN"]
-        @client = OpenAI::Client.new(
-          access_token: @access_token,
-          uri_base: @host,
-          organization_id: @organization_id,
-          admin_token: @admin_token,
-          log_errors: Rails.env.development?
-        )
+        @options = namespace::Options.new(**options.except("service"))
+      end
 
-        @model_name = config["model"] || "gpt-4o-mini"
+      # @return [OpenAI::Client]
+      def client(prompt_options = nil)
+        if prompt_options
+          ::OpenAI::Client.new(namespace::Options.new(prompt_options).client_options)
+        else
+          @client ||= ::OpenAI::Client.new(@options.client_options)
+        end
       end
 
       def generate(prompt)
@@ -48,6 +48,8 @@ def embed(prompt)
 
       protected
 
+      def namespace = OpenAI
+
       # Override from StreamProcessing module
       def process_stream_chunk(chunk, message, agent_stream)
         new_content = chunk.dig("choices", 0, "delta", "content")
@@ -167,17 +169,19 @@ def handle_message(message_json)
 
       # handle_actions is now provided by ToolManagement module
 
+      # @todo prompt_parameters client options overriding
       def chat_prompt(parameters: prompt_parameters)
-        if prompt.options[:stream] || config["stream"]
+        if prompt.options[:stream] || client.stream
           parameters[:stream] = provider_stream
           @streaming_request_params = parameters
         end
-        chat_response(@client.chat(parameters: parameters), parameters)
+        chat_response(client.chat(parameters: parameters), parameters)
       end
 
+      # @todo prompt_parameters client options overriding
       def responses_prompt(parameters: responses_parameters)
         # parameters[:stream] = provider_stream if prompt.options[:stream] || config["stream"]
-        responses_response(@client.responses.create(parameters: parameters), parameters)
+        responses_response(client.responses.create(parameters: parameters), parameters)
       end
 
       def responses_parameters(model: @prompt.options[:model] || @model_name, messages: @prompt.messages, temperature: @prompt.options[:temperature] || @config["temperature"] || 0.7, tools: @prompt.actions, structured_output: @prompt.output_schema)
@@ -258,9 +262,10 @@ def embeddings_response(response, request_params = nil)
         )
       end
 
+      # @todo prompt_parameters client options overriding
       def embeddings_prompt(parameters:)
         params = embeddings_parameters
-        embeddings_response(@client.embeddings(parameters: params), params)
+        embeddings_response(client.embeddings(parameters: params), params)
       end
     end
   end