active_harness 0.1.0 → 0.2.0

data/lib/active_harness/rate_limit/risk_holdback.rb

@@ -1,69 +0,0 @@
-module ActiveHarness
-  module RateLimit
-    # Progressive hold-back for users who repeatedly submit risky requests.
-    #
-    # Every RISKY_THRESHOLD blocked requests trigger a hold. The hold duration
-    # escalates with each offense:
-    #
-    #   Offense 1 (3rd  risky request) →  5 minutes
-    #   Offense 2 (6th  risky request) → 30 minutes
-    #   Offense 3+ (9th+ risky request) →  2 hours
-    #
-    # Storage is in-memory (per-process). Thread-safe via Mutex.
-    #
-    # Usage:
-    #   holdback = RiskHoldback.new
-    #   holdback.check!(user_id)           # before each request; raises if held
-    #   holdback.record_risky!(user_id)    # after guard blocks a request
-    #
-    class RiskHoldback
-      RISKY_THRESHOLD = 3
-      HOLD_SCHEDULE   = [5 * 60, 30 * 60, 2 * 60 * 60].freeze  # 5 min / 30 min / 2 h
-
-      # @param risky_threshold [Integer]  number of risky requests before a hold is applied
-      def initialize(risky_threshold: RISKY_THRESHOLD)
-        @risky_threshold = risky_threshold
-        @state           = {}
-        @mutex           = Mutex.new
-      end
-
-      # Records a risky (guard-blocked) request for the user.
-      # Applies a hold when the count reaches the next threshold multiple.
-      # @param user_id [String, Integer, nil]  nil is a no-op
-      def record_risky!(user_id)
-        return if user_id.nil?
-
-        key = user_id.to_s
-        @mutex.synchronize do
-          s = @state[key] ||= { risky_count: 0, offense_count: 0, held_until: nil }
-          s[:risky_count] += 1
-
-          if (s[:risky_count] % @risky_threshold).zero?
-            offense_idx      = [s[:offense_count], HOLD_SCHEDULE.size - 1].min
-            s[:held_until]   = Time.now.to_f + HOLD_SCHEDULE[offense_idx]
-            s[:offense_count] += 1
-          end
-        end
-      end
-
-      # Raises if the user is currently held back due to risky behaviour.
-      # @param user_id [String, Integer, nil]  nil disables the check
-      # @raise [Errors::UserHoldbackError]
-      def check!(user_id)
-        return if user_id.nil?
-
-        key = user_id.to_s
-        @mutex.synchronize do
-          s = @state[key]
-          return unless s&.dig(:held_until)
-          return if Time.now.to_f >= s[:held_until]
-
-          remaining = (s[:held_until] - Time.now.to_f).ceil
-          raise Errors::UserHoldbackError,
-            "Requests paused due to repeated safety violations. " \
-            "Retry in #{remaining}s (user: #{key})"
-        end
-      end
-    end
-  end
-end

data/lib/active_harness/results/debug_result.rb

@@ -1,19 +0,0 @@
-module ActiveHarness
-  # Available only when ActiveHarness.config.debug == true
-  class DebugResult
-    attr_reader :system_prompt,
-                :guard_runs,
-                :callback_log
-
-    def initialize(system_prompt: nil,
-                   guard_runs: [], callback_log: [])
-      @system_prompt = system_prompt
-      @guard_runs    = guard_runs
-      @callback_log  = callback_log
-    end
-
-    def full_prompt
-      @system_prompt.to_s
-    end
-  end
-end

data/lib/active_harness/results/input_result.rb

@@ -1,27 +0,0 @@
-module ActiveHarness
-  # Holds the result of the guard (input safety) layer.
-  class InputResult
-    attr_reader :raw, :processed, :errors, :risk_level, :intent, :reason
-
-    def initialize(raw:, processed:, safe:, valid:,
-                   risk_level: :low, errors: [],
-                   intent: nil, reason: nil)
-      @raw        = raw
-      @processed  = processed
-      @safe       = safe
-      @valid      = valid
-      @risk_level = risk_level
-      @errors     = errors
-      @intent     = intent
-      @reason     = reason
-    end
-
-    def safe?
-      @safe
-    end
-
-    def valid?
-      @valid
-    end
-  end
-end

data/lib/active_harness/results/result.rb

@@ -1,55 +0,0 @@
-module ActiveHarness
-  class Result
-    SUCCESS = :success
-    FAILED  = :failed
-    BLOCKED = :blocked
-
-    attr_reader :input, :output, :raw_response,
-                :provider, :model, :usage, :attempts,
-                :debug, :error
-
-    def initialize(status:, input: nil, output: nil, raw_response: nil,
-                   provider: nil, model: nil, usage: {}, attempts: [],
-                   debug: nil, error: nil)
-      @status       = status
-      @input        = input
-      @output       = output
-      @raw_response = raw_response
-      @provider     = provider
-      @model        = model
-      @usage        = usage
-      @attempts     = attempts
-      @debug        = debug
-      @error        = error
-    end
-
-    def success?
-      @status == SUCCESS
-    end
-
-    def failed?
-      @status == FAILED
-    end
-
-    def blocked?
-      @status == BLOCKED
-    end
-
-    # Factory helpers
-
-    def self.success(input:, output:, raw_response:, provider:, model:,
-                     usage:, attempts:, debug: nil)
-      new(status: SUCCESS, input: input, output: output,
-          raw_response: raw_response, provider: provider,
-          model: model, usage: usage, attempts: attempts, debug: debug)
-    end
-
-    def self.blocked(input:, output: nil, debug: nil)
-      new(status: BLOCKED, input: input, output: output, debug: debug)
-    end
-
-    def self.failed(error: nil, input: nil, debug: nil)
-      new(status: FAILED, error: error, input: input, debug: debug)
-    end
-  end
-end