agent-harness 0.5.7 → 0.5.9

data/lib/agent_harness/provider_health_check.rb

@@ -431,17 +431,39 @@ module AgentHarness
       end
 
       def build_provider(provider_name, klass, executor:)
-        config = AgentHarness.configuration.providers[provider_name]
-        klass.new(
-          config: config,
-          executor: executor || AgentHarness.configuration.command_executor,
-          logger: AgentHarness.logger
-        )
+        canonical_name = Providers::Registry.instance.canonical_name(provider_name)
+        config = provider_config_for(provider_name, canonical_name: canonical_name)
+        executor ||= AgentHarness.configuration.command_executor
+        logger = AgentHarness.logger
+
+        provider = if klass.respond_to?(:build_provider_instance, true)
+          klass.send(:build_provider_instance, config: config, executor: executor, logger: logger)
+        else
+          klass.new(config: config, executor: executor, logger: logger)
+        end
+
+        # Ensure the executor is available even when the provider constructor
+        # accepts only a subset of keywords (e.g. config: only).
+        if provider.respond_to?(:executor=) && provider.executor.nil?
+          provider.executor = executor
+        elsif !provider.respond_to?(:executor)
+          provider.define_singleton_method(:executor) { executor }
+        end
+
+        provider
       end
 
       def monotonic_now
         Process.clock_gettime(Process::CLOCK_MONOTONIC)
       end
+
+      def provider_config_for(requested_name, canonical_name:)
+        requested_key = requested_name.to_sym
+        canonical_key = canonical_name.to_sym
+
+        AgentHarness.configuration.providers[requested_key] ||
+          AgentHarness.configuration.providers[canonical_key]
+      end
     end
   end
 end

data/lib/agent_harness/provider_runtime.rb

@@ -35,11 +35,15 @@ module AgentHarness
     # @param unset_env [Array<String>] environment variable names to remove from inherited env
     # @param metadata [Hash] arbitrary provider-specific data
     def initialize(model: nil, base_url: nil, api_provider: nil, env: {}, flags: [], unset_env: [], metadata: {})
+      validate_optional_string!(:model, model)
+      validate_optional_string!(:base_url, base_url)
+      validate_optional_string!(:api_provider, api_provider)
+
       @model = model
       @base_url = base_url
       @api_provider = api_provider
 
-      env_hash = env || {}
+      env_hash = env.nil? ? {} : env
       unless env_hash.is_a?(Hash)
         raise ArgumentError, "env must be a Hash (got #{env_hash.class})"
       end
@@ -52,7 +56,7 @@ module AgentHarness
       end
       @env = normalized_env.freeze
 
-      normalized_flags = flags || []
+      normalized_flags = flags.nil? ? [] : flags
       unless normalized_flags.is_a?(Array)
         raise ArgumentError, "flags must be an Array (got #{normalized_flags.class})"
       end
@@ -65,7 +69,7 @@ module AgentHarness
       end
       @flags = normalized_flags.freeze
 
-      metadata_hash = metadata || {}
+      metadata_hash = metadata.nil? ? {} : metadata
       unless metadata_hash.is_a?(Hash)
         raise ArgumentError, "metadata must be a Hash (got #{metadata_hash.class})"
       end
@@ -74,7 +78,7 @@ module AgentHarness
       # Unset environment variables for the request. These are variable names that
       # should be removed from the inherited environment before the provider
       # command runs.
-      unset_array = unset_env || []
+      unset_array = unset_env.nil? ? [] : unset_env
       unless unset_array.is_a?(Array)
         raise ArgumentError, "unset_env must be an Array (got #{unset_array.class})"
       end
@@ -96,14 +100,19 @@ module AgentHarness
     def self.from_hash(hash)
       raise ArgumentError, "expected a Hash, got #{hash.class}" unless hash.is_a?(Hash)
 
+      env_val = hash_value(hash, :env)
+      flags_val = hash_value(hash, :flags)
+      unset_env_val = hash_value(hash, :unset_env)
+      metadata_val = hash_value(hash, :metadata)
+
       new(
-        model: hash[:model] || hash["model"],
-        base_url: hash[:base_url] || hash["base_url"],
-        api_provider: hash[:api_provider] || hash["api_provider"],
-        env: hash[:env] || hash["env"] || {},
-        flags: hash[:flags] || hash["flags"] || [],
-        unset_env: hash[:unset_env] || hash["unset_env"] || [],
-        metadata: hash[:metadata] || hash["metadata"] || {}
+        model: hash_value(hash, :model),
+        base_url: hash_value(hash, :base_url),
+        api_provider: hash_value(hash, :api_provider),
+        env: env_val.nil? ? {} : env_val,
+        flags: flags_val.nil? ? [] : flags_val,
+        unset_env: unset_env_val.nil? ? [] : unset_env_val,
+        metadata: metadata_val.nil? ? {} : metadata_val
       )
     end
 
@@ -128,5 +137,23 @@ module AgentHarness
       model.nil? && base_url.nil? && api_provider.nil? &&
         env.empty? && flags.empty? && metadata.empty? && unset_env.empty?
     end
+
+    private_class_method def self.hash_value(hash, key)
+      sym_value = hash[key]
+      str_value = hash[key.to_s]
+      # Prefer the symbol key; fall back to the string key only when the
+      # symbol key is nil (not just falsy) so that an explicit `false` is
+      # not silently discarded.
+      sym_value.nil? ? str_value : sym_value
+    end
+
+    private
+
+    def validate_optional_string!(name, value)
+      return if value.nil?
+      return if value.is_a?(String)
+
+      raise ArgumentError, "#{name} must be a String or nil (got #{value.class})"
+    end
   end
 end