ruby_llm-agents 3.5.4 → 3.6.0

data/lib/ruby_llm/agents/infrastructure/reliability/executor.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module Agents
-    module Reliability
-      # Coordinates reliability features during agent execution
-      #
-      # Orchestrates retry strategy, fallback routing, circuit breakers,
-      # and execution constraints into a cohesive execution flow.
-      #
-      # @example
-      #   executor = Executor.new(
-      #     config: { retries: { max: 3 }, fallback_models: ["gpt-4o-mini"] },
-      #     primary_model: "gpt-4o",
-      #     agent_type: "MyAgent"
-      #   )
-      #   executor.execute { |model| call_llm(model) }
-      #
-      # @api private
-      class Executor
-        attr_reader :retry_strategy, :fallback_routing, :breaker_manager, :constraints
-
-        # @param config [Hash] Reliability configuration
-        # @param primary_model [String] Primary model identifier
-        # @param agent_type [String] Agent class name
-        # @param tenant_id [String, nil] Optional tenant identifier
-        def initialize(config:, primary_model:, agent_type:, tenant_id: nil)
-          retries_config = config[:retries] || {}
-
-          @retry_strategy = RetryStrategy.new(
-            max: retries_config[:max] || 0,
-            backoff: retries_config[:backoff] || :exponential,
-            base: retries_config[:base] || 0.4,
-            max_delay: retries_config[:max_delay] || 3.0,
-            on: retries_config[:on] || [],
-            patterns: config[:retryable_patterns]
-          )
-
-          @fallback_routing = FallbackRouting.new(
-            primary_model,
-            fallback_models: config[:fallback_models] || []
-          )
-
-          @breaker_manager = BreakerManager.new(
-            agent_type,
-            config: config[:circuit_breaker],
-            tenant_id: tenant_id
-          )
-
-          @constraints = ExecutionConstraints.new(
-            total_timeout: config[:total_timeout]
-          )
-
-          @last_error = nil
-        end
-
-        # Returns all models that will be tried
-        #
-        # @return [Array<String>] Model identifiers
-        def models_to_try
-          fallback_routing.models
-        end
-
-        # Executes with full reliability support
-        #
-        # Iterates through models with retries, respecting circuit breakers
-        # and timeout constraints.
-        #
-        # @yield [model] Block to execute with the current model
-        # @yieldparam model [String] The model to use for this attempt
-        # @return [Object] Result of successful execution
-        # @raise [AllModelsExhaustedError] If all models fail
-        # @raise [TotalTimeoutError] If total timeout exceeded
-        def execute
-          until fallback_routing.exhausted?
-            model = fallback_routing.current_model
-
-            # Check circuit breaker
-            if breaker_manager.open?(model)
-              fallback_routing.advance!
-              next
-            end
-
-            # Try with retries
-            result = execute_with_retries(model) { |m| yield(m) }
-            return result if result
-
-            fallback_routing.advance!
-          end
-
-          raise AllModelsExhaustedError.new(
-            fallback_routing.models,
-            @last_error || StandardError.new("All models failed")
-          )
-        end
-
-        private
-
-        def execute_with_retries(model)
-          attempt_index = 0
-
-          loop do
-            constraints.enforce_timeout!
-
-            begin
-              result = yield(model)
-              breaker_manager.record_success!(model)
-              return result
-            rescue => e
-              @last_error = e
-              breaker_manager.record_failure!(model)
-
-              if retry_strategy.retryable?(e) && retry_strategy.should_retry?(attempt_index)
-                attempt_index += 1
-                sleep(retry_strategy.delay_for(attempt_index))
-              else
-                return nil # Move to next model
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ruby_llm/agents/infrastructure/reliability/fallback_routing.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module Agents
-    module Reliability
-      # Routes execution through fallback models when primary fails
-      #
-      # Manages the model fallback chain and tracks which models have been tried.
-      #
-      # @example
-      #   routing = FallbackRouting.new("gpt-4o", fallback_models: ["gpt-4o-mini"])
-      #   routing.current_model  # => "gpt-4o"
-      #   routing.advance!       # => "gpt-4o-mini"
-      #   routing.exhausted?     # => false
-      #
-      # @api private
-      class FallbackRouting
-        attr_reader :models
-
-        # @param primary_model [String] The primary model identifier
-        # @param fallback_models [Array<String>] Fallback model identifiers
-        def initialize(primary_model, fallback_models: [])
-          @models = [primary_model, *fallback_models].uniq
-          @current_index = 0
-        end
-
-        # Returns the current model to try
-        #
-        # @return [String, nil] Model identifier or nil if exhausted
-        def current_model
-          models[@current_index]
-        end
-
-        # Advances to the next fallback model
-        #
-        # @return [String, nil] Next model or nil if exhausted
-        def advance!
-          @current_index += 1
-          current_model
-        end
-
-        # Checks if more models are available after current
-        #
-        # @return [Boolean] true if more models to try
-        def has_more?
-          @current_index < models.length - 1
-        end
-
-        # Checks if all models have been exhausted
-        #
-        # @return [Boolean] true if no more models
-        def exhausted?
-          @current_index >= models.length
-        end
-
-        # Resets to the first model
-        #
-        # @return [void]
-        def reset!
-          @current_index = 0
-        end
-
-        # Returns models that have been tried so far
-        #
-        # @return [Array<String>] Models already attempted
-        def tried_models
-          models[0..@current_index]
-        end
-      end
-    end
-  end
-end

data/lib/ruby_llm/agents/infrastructure/reliability/retry_strategy.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module Agents
-    module Reliability
-      # Handles retry logic with configurable backoff strategies
-      #
-      # Provides exponential and constant backoff with jitter,
-      # retry counting, and delay calculation.
-      #
-      # @example
-      #   strategy = RetryStrategy.new(max: 3, backoff: :exponential, base: 0.4)
-      #   strategy.should_retry?(attempt_index) # => true/false
-      #   strategy.delay_for(attempt_index)     # => 0.6 (with jitter)
-      #
-      # @api private
-      class RetryStrategy
-        attr_reader :max, :backoff, :base, :max_delay, :custom_errors, :custom_patterns
-
-        # @param max [Integer] Maximum retry attempts
-        # @param backoff [Symbol] :constant or :exponential
-        # @param base [Float] Base delay in seconds
-        # @param max_delay [Float] Maximum delay cap
-        # @param on [Array<Class>] Additional error classes to retry on
-        # @param patterns [Array<String>, nil] Additional patterns to match in error messages
-        def initialize(max: 0, backoff: :exponential, base: 0.4, max_delay: 3.0, on: [], patterns: nil)
-          @max = max
-          @backoff = backoff
-          @base = base
-          @max_delay = max_delay
-          @custom_errors = Array(on)
-          @custom_patterns = patterns
-        end
-
-        # Determines if retry should occur
-        #
-        # @param attempt_index [Integer] Current attempt number (0-indexed)
-        # @return [Boolean] true if should retry
-        def should_retry?(attempt_index)
-          attempt_index < max
-        end
-
-        # Calculates delay before next retry
-        #
-        # @param attempt_index [Integer] Current attempt number
-        # @return [Float] Delay in seconds (includes jitter)
-        def delay_for(attempt_index)
-          base_delay = case backoff
-          when :constant
-            base
-          when :exponential
-            [base * (2**attempt_index), max_delay].min
-          else
-            base
-          end
-
-          # Add jitter (0-50% of base delay)
-          base_delay + (rand * base_delay * 0.5)
-        end
-
-        # Checks if an error is retryable
-        #
-        # @param error [Exception] The error to check
-        # @return [Boolean] true if retryable
-        def retryable?(error)
-          RubyLLM::Agents::Reliability.retryable_error?(
-            error,
-            custom_errors: custom_errors,
-            custom_patterns: custom_patterns
-          )
-        end
-
-        # Returns all retryable error classes
-        #
-        # @return [Array<Class>] Error classes to retry on
-        def retryable_errors
-          RubyLLM::Agents::Reliability.default_retryable_errors + custom_errors
-        end
-      end
-    end
-  end
-end