agent-harness 0.5.5 → 0.5.7

data/lib/agent_harness/docker_command_executor.rb

@@ -35,12 +35,20 @@ module AgentHarness
     #
     # @param command [Array<String>, String] command to execute
     # @param timeout [Integer, nil] timeout in seconds
+    # @param idle_timeout [Integer, Float, nil] idle timeout in seconds based on output activity
     # @param env [Hash] environment variables to set in the container
     # @param stdin_data [String, nil] data to send to stdin
     # @return [Result] execution result
-    def execute(command, timeout: nil, env: {}, stdin_data: nil)
+    def execute(command, timeout: nil, idle_timeout: nil, env: {}, stdin_data: nil, **execution_options)
       docker_cmd = build_docker_command(command, env: env, stdin_data: stdin_data)
-      super(docker_cmd, timeout: timeout, env: {}, stdin_data: stdin_data)
+      super(
+        docker_cmd,
+        timeout: timeout,
+        idle_timeout: idle_timeout,
+        env: {},
+        stdin_data: stdin_data,
+        **execution_options
+      )
     end
 
     # Check if a binary exists inside the container
@@ -62,11 +70,23 @@ module AgentHarness
 
     def build_docker_command(command, env:, stdin_data:)
       cmd = ["docker", "exec"]
+      unset_env_keys = []
 
-      env.each { |key, value| cmd.push("--env", "#{key}=#{value}") }
+      env.each do |key, value|
+        if value.nil?
+          unset_env_keys << key
+          next
+        end
+
+        cmd.push("--env", "#{key}=#{value}")
+      end
       cmd.push("-i") if stdin_data
 
       cmd.push(@container_id)
+      unless unset_env_keys.empty?
+        cmd.push("env")
+        unset_env_keys.each { |key| cmd.push("-u", key) }
+      end
 
       cmd.concat(normalize_command(command))
     end

data/lib/agent_harness/error_taxonomy.rb

@@ -39,6 +39,11 @@ module AgentHarness
         action: :retry_with_backoff,
         retryable: true
       },
+      idle_timeout: {
+        description: "Operation exceeded idle timeout",
+        action: :escalate,
+        retryable: false
+      },
       sandbox_failure: {
         description: "Sandbox setup failed",
         action: :escalate,
@@ -58,6 +63,9 @@ module AgentHarness
       # @param patterns [Hash<Symbol, Array<Regexp>>] provider-specific patterns
       # @return [Symbol] error category
       def classify(error, patterns = {})
+        return :idle_timeout if error.is_a?(IdleTimeoutError)
+        return :timeout if error.is_a?(TimeoutError)
+
         message = error.message.to_s.downcase
 
         # Check provider-specific patterns first
@@ -112,6 +120,8 @@ module AgentHarness
 
       def classify_generic(message)
         case message
+        when /idle.?timeout/i
+          :idle_timeout
         when /rate.?limit|too many requests|429/i
           :rate_limited
         when /quota|usage.?limit|billing/i

data/lib/agent_harness/errors.rb

@@ -22,6 +22,11 @@ module AgentHarness
   # Execution errors
   class TimeoutError < Error; end
 
+  # Raised when a duration argument is invalid (non-positive)
+  class InvalidDurationError < ArgumentError; end
+
+  class IdleTimeoutError < TimeoutError; end
+
   class CommandExecutionError < Error; end
 
   # Rate limiting and circuit breaker errors

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,18 @@ module AgentHarness
         end
       end
 
-      def create_provider(name)
+      def create_provider(name, executor: @config.command_executor)
         klass = @registry.get(name)
         config = @config.providers[name]
 
         klass.new(
           config: config,
-          executor: @config.command_executor,
+          executor: executor,
           logger: AgentHarness.logger
         )
       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 +227,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