agent-harness 0.5.6 → 0.5.8

data/lib/agent_harness/orchestration/conductor.rb

@@ -33,13 +33,14 @@ module AgentHarness
       # @param prompt [String] the prompt to send
       # @param provider [Symbol, nil] preferred provider
       # @param model [String, nil] model to use
+      # @param executor [CommandExecutor, nil] per-request executor override
       # @param options [Hash] additional options
       # @return [Response] the response
       # @raise [NoProvidersAvailableError] if all providers fail
-      def send_message(prompt, provider: nil, model: nil, **options)
+      def send_message(prompt, provider: nil, model: nil, executor: nil, **options)
         provider_name = provider || @config.default_provider
 
-        with_orchestration(provider_name, model, options) do |selected_provider|
+        with_orchestration(provider_name, model, executor, options) do |selected_provider|
           selected_provider.send_message(prompt: prompt, model: model, **options)
         end
       end
@@ -50,8 +51,8 @@ module AgentHarness
       # @param provider [Symbol] the provider to use
       # @param options [Hash] additional options
       # @return [Response] the response
-      def execute_direct(prompt, provider:, **options)
-        provider_instance = @provider_manager.get_provider(provider)
+      def execute_direct(prompt, provider:, executor: nil, **options)
+        provider_instance = @provider_manager.get_provider(provider, executor: executor)
         provider_instance.send_message(prompt: prompt, **options)
       end
 
@@ -77,7 +78,7 @@ module AgentHarness
 
       private
 
-      def with_orchestration(provider_name, model, options)
+      def with_orchestration(provider_name, model, executor, options)
         retries = 0
         retry_config = @config.orchestration_config.retry_config
         max_retries = retry_config.max_attempts
@@ -85,7 +86,7 @@ module AgentHarness
 
         begin
           # Select provider (may return different provider based on health)
-          provider = @provider_manager.select_provider(provider_name)
+          provider = @provider_manager.select_provider(provider_name, executor: executor)
           provider_name = provider.class.provider_name
           attempted_providers << provider_name
 
@@ -98,7 +99,9 @@ module AgentHarness
 
           # Record success
           @metrics.record_success(provider_name, duration)
-          @provider_manager.record_success(provider_name)
+          # Only update shared health state for default-executor traffic;
+          # request-scoped executor successes must not heal the global provider.
+          @provider_manager.record_success(provider_name) unless executor
 
           response
         rescue AuthenticationError => e
@@ -113,17 +116,31 @@ module AgentHarness
           @metrics.record_failure(provider_name, e)
           raise
         rescue RateLimitError => e
-          @provider_manager.mark_rate_limited(provider_name, reset_at: e.reset_time)
-          handle_provider_failure(e, provider_name, :switch)
+          # Only update shared rate-limit state for default-executor traffic;
+          # request-scoped executor failures must not poison the global provider.
+          @provider_manager.mark_rate_limited(provider_name, reset_at: e.reset_time) unless executor
+          provider_name = handle_provider_failure(e, provider_name, :switch, executor: executor)
           retry if should_retry?(retries += 1, max_retries)
           raise
         rescue CircuitOpenError => e
-          handle_provider_failure(e, provider_name, :switch)
+          provider_name = handle_provider_failure(e, provider_name, :switch, executor: executor)
           retry if should_retry?(retries += 1, max_retries)
           raise
-        rescue TimeoutError, ProviderError => e
+        rescue IdleTimeoutError => e
+          @metrics.record_failure(provider_name, e)
           @provider_manager.record_failure(provider_name)
-          handle_provider_failure(e, provider_name, :retry)
+          raise
+        rescue TimeoutError, ProviderError => e
+          # Only update shared health state for default-executor traffic;
+          # request-scoped executor failures must not poison the global provider.
+          @provider_manager.record_failure(provider_name) unless executor
+          # For executor-scoped requests we skip record_failure (above), so
+          # shared health/circuit state never degrades and select_provider
+          # would keep returning the same failing provider on retry.  Use
+          # :switch instead of :retry so the request can still fall back to a
+          # healthy provider without poisoning global state.
+          strategy = executor ? :switch : :retry
+          provider_name = handle_provider_failure(e, provider_name, strategy, executor: executor)
           retry if should_retry?(retries += 1, max_retries)
           raise
         rescue NoProvidersAvailableError
@@ -131,10 +148,12 @@ module AgentHarness
           raise
         rescue => e
           @metrics.record_failure(provider_name, e)
-          @provider_manager.record_failure(provider_name)
+          # Only update shared health state for default-executor traffic;
+          # request-scoped executor failures must not poison the global provider.
+          @provider_manager.record_failure(provider_name) unless executor
 
           # Try switching for unknown errors
-          handle_provider_failure(e, provider_name, :switch)
+          provider_name = handle_provider_failure(e, provider_name, :switch, executor: executor)
           retry if should_retry?(retries += 1, max_retries)
           raise ProviderError.new(e.message, original_error: e)
         end
@@ -145,7 +164,7 @@ module AgentHarness
         current_retries < max_retries
       end
 
-      def handle_provider_failure(error, provider_name, strategy)
+      def handle_provider_failure(error, provider_name, strategy, executor: nil)
         @metrics.record_failure(provider_name, error)
 
         case strategy
@@ -153,8 +172,10 @@ module AgentHarness
           if @config.orchestration_config.auto_switch_on_error
             new_provider = begin
               @provider_manager.switch_provider(
+                from: provider_name,
                 reason: error.class.name,
-                context: {error: error.message}
+                context: {error: error.message},
+                executor: executor
               )
             rescue NoProvidersAvailableError
               nil
@@ -162,12 +183,15 @@ module AgentHarness
 
             if new_provider
               @metrics.record_switch(provider_name, new_provider.class.provider_name, error.class.name)
+              return new_provider.class.provider_name
             end
           end
         when :retry
           delay = calculate_retry_delay
           sleep(delay) if delay > 0
         end
+
+        provider_name
       end
 
       def calculate_retry_delay

data/lib/agent_harness/orchestration/provider_manager.rb

@@ -30,49 +30,57 @@ module AgentHarness
       # Select best available provider
       #
       # @param preferred [Symbol, nil] preferred provider name
+      # @param executor [CommandExecutor, nil] per-request executor override
       # @return [Providers::Base] selected provider instance
       # @raise [NoProvidersAvailableError] if no providers available
-      def select_provider(preferred = nil)
+      def select_provider(preferred = nil, executor: nil)
         preferred ||= @current_provider
 
         # Check circuit breaker
         if circuit_open?(preferred)
-          return select_fallback(preferred, reason: :circuit_open)
+          return select_fallback(preferred, reason: :circuit_open, executor: executor)
         end
 
         # Check rate limit
         if rate_limited?(preferred)
-          return select_fallback(preferred, reason: :rate_limited)
+          return select_fallback(preferred, reason: :rate_limited, executor: executor)
         end
 
         # Check health
         unless healthy?(preferred)
-          return select_fallback(preferred, reason: :unhealthy)
+          return select_fallback(preferred, reason: :unhealthy, executor: executor)
         end
 
-        get_provider(preferred)
+        get_provider(preferred, executor: executor)
       end
 
       # Get or create provider instance
       #
       # @param name [Symbol, String] the provider name
+      # @param executor [CommandExecutor, nil] per-request executor override
       # @return [Providers::Base] the provider instance
-      def get_provider(name)
+      def get_provider(name, executor: nil)
         name = name.to_sym
+        return create_provider(name, executor: executor) if executor
+
         @provider_instances[name] ||= create_provider(name)
       end
 
       # Switch to next available provider
       #
+      # @param from [Symbol, String] provider that failed and should be switched from
       # @param reason [Symbol, String] reason for switch
       # @param context [Hash] additional context
+      # @param executor [CommandExecutor, nil] per-request executor override
       # @return [Providers::Base, nil] new provider or nil if none available
-      def switch_provider(reason:, context: {})
-        old_provider = @current_provider
+      def switch_provider(reason:, context: {}, executor: nil, from: @current_provider)
+        old_provider = from.to_sym
 
-        fallback = select_fallback(@current_provider, reason: reason)
+        fallback = select_fallback(old_provider, reason: reason, executor: executor)
         return nil unless fallback
 
+        return fallback if executor
+
         @current_provider = fallback.class.provider_name
 
         AgentHarness.logger&.info(
@@ -195,18 +203,30 @@ module AgentHarness
         end
       end
 
-      def create_provider(name)
+      def create_provider(name, executor: @config.command_executor)
         klass = @registry.get(name)
-        config = @config.providers[name]
+        canonical_name = @registry.canonical_name(name)
+        config = provider_config_for(name, canonical_name: canonical_name)
+        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
 
-        klass.new(
-          config: config,
-          executor: @config.command_executor,
-          logger: AgentHarness.logger
-        )
+        # 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 select_fallback(provider_name, reason:)
+      def select_fallback(provider_name, reason:, executor: nil)
         chain = @fallback_chains[provider_name] || build_fallback_chain(provider_name)
 
         chain.each do |fallback_name|
@@ -219,7 +239,7 @@ module AgentHarness
             "[AgentHarness::ProviderManager] Falling back from #{provider_name} to #{fallback_name} (#{reason})"
           )
 
-          return get_provider(fallback_name)
+          return get_provider(fallback_name, executor: executor)
         end
 
         # No fallback available
@@ -235,6 +255,14 @@ module AgentHarness
         chain += @config.providers.keys
         chain.uniq
       end
+
+      def provider_config_for(requested_name, canonical_name:)
+        requested_key = requested_name.to_sym
+        canonical_key = canonical_name.to_sym
+
+        @config.providers[requested_key] ||
+          @config.providers[canonical_key]
+      end
     end
   end
 end