active_harness 0.2.42 → 0.3.0

data/lib/active_harness/{agent → request}/models.rb

@@ -1,5 +1,5 @@
 module ActiveHarness
-  class Agent
+  class Request
     class << self
       # Array-style model list:
       #
@@ -8,10 +8,10 @@ module ActiveHarness
       #     { provider: :openrouter, model: "mistralai/mistral-nemo" }
       #   ]
       def models(list)
-        agent_config[:models] = Array(list)
+        request_config[:models] = Array(list)
       end
 
-      # Output format for this agent.
+      # Output format for this request.
       #
       #   format :text   # default — output is returned as-is
       #   format :json   # output is parsed; result.processed is a Ruby Hash/Array
@@ -20,7 +20,7 @@ module ActiveHarness
           raise ArgumentError, "Unknown format :#{type}. Valid values: :text, :json"
         end
 
-        agent_config[:format] = type
+        request_config[:format] = type
       end
 
       # Block-based model DSL:
@@ -32,16 +32,16 @@ module ActiveHarness
       def model(&block)
         config = ModelConfig.new
         config.instance_eval(&block)
-        agent_config[:model] = config.to_h
+        request_config[:model] = config.to_h
       end
     end
 
-    # Public instance API — returns a ModelList proxy for this agent instance.
+    # Public instance API — returns a ModelList proxy for this request instance.
     #
-    # Allows adding models at runtime before calling the agent:
+    # Allows adding models at runtime before calling the request:
     #
-    #   agent.models.prepend([{ provider: :openrouter, model: "..." }])
-    #   agent.models.push([{ provider: :openrouter, model: "..." }])
+    #   request.models.prepend([{ provider: :openrouter, model: "..." }])
+    #   request.models.push([{ provider: :openrouter, model: "..." }])
     #
     # Any prepended/pushed models are combined with the class-defined chain:
     #   [prepended...] + [class chain / constructor override] + [pushed...]
@@ -69,7 +69,7 @@ module ActiveHarness
   end
 
   # ---------------------------------------------------------------------------
-  # ModelList — mutable proxy returned by agent.models
+  # ModelList — mutable proxy returned by request.models
   # ---------------------------------------------------------------------------
   class ModelList
     def initialize(base_models)
@@ -93,7 +93,7 @@ module ActiveHarness
 
     # Replace the entire chain, discarding prepended/appended too.
     #
-    #   agent.models.replace([{ provider: :openrouter, model: "..." }])
+    #   request.models.replace([{ provider: :openrouter, model: "..." }])
     def replace(models)
       @base      = Array(models)
       @prepended = []
@@ -104,9 +104,9 @@ module ActiveHarness
     # Insert a single model entry at an arbitrary position in the final chain.
     # Position 0 is the same as prepend; -1 appends after the last element.
     #
-    #   agent.models.insert(0,  { provider: :openrouter, model: "fast-model" })
-    #   agent.models.insert(2,  { provider: :openrouter, model: "mid-model" })
-    #   agent.models.insert(-1, { provider: :openrouter, model: "last-resort" })
+    #   request.models.insert(0,  { provider: :openrouter, model: "fast-model" })
+    #   request.models.insert(2,  { provider: :openrouter, model: "mid-model" })
+    #   request.models.insert(-1, { provider: :openrouter, model: "last-resort" })
     def insert(position, model)
       to_a.tap { |list| list.insert(position, model) }.then do |new_list|
         @prepended = []
@@ -127,7 +127,7 @@ module ActiveHarness
   end
 
   # ---------------------------------------------------------------------------
-  # DSL builder — used by Agent.model { ... }
+  # DSL builder — used by Request.model { ... }
   # ---------------------------------------------------------------------------
   class ModelConfig
     def initialize

data/lib/active_harness/{agent → request}/output_parser.rb

@@ -1,5 +1,5 @@
 module ActiveHarness
-  class Agent
+  class Request
     private
 
     # Strips markdown code fences that some models add despite being told not to:

data/lib/active_harness/{agent → request}/prompt.rb

@@ -1,7 +1,7 @@
 module ActiveHarness
-  class Agent
+  class Request
     class << self
-      # System prompt for this agent.
+      # System prompt for this request.
       # Accepts:
       #   - a String  → used as-is
       #   - a Class   → instantiated and resolved via #call or #text
@@ -11,7 +11,7 @@ module ActiveHarness
       #   system_prompt MyPromptClass
       #   system_prompt -> { "Dynamic prompt built at #{Time.now}" }
       def system_prompt(text_or_class)
-        agent_config[:system_prompt] = text_or_class
+        request_config[:system_prompt] = text_or_class
       end
       alias prompt system_prompt
     end
@@ -32,13 +32,13 @@ module ActiveHarness
       when Proc     then instance_exec(&sp)
       when Class
         instance = sp.new
-        inject_agent_state(instance)
+        inject_request_state(instance)
         if    instance.respond_to?(:call) then instance.call
         elsif instance.respond_to?(:text) then instance.text
         else  instance.to_s
         end
       else
-        inject_agent_state(sp)
+        inject_request_state(sp)
         if    sp.respond_to?(:call) then sp.call
         elsif sp.respond_to?(:text) then sp.text
         else  sp.to_s
@@ -49,9 +49,9 @@ module ActiveHarness
       prompt
     end
 
-    # Injects agent state into a prompt class instance before #call.
+    # Injects request state into a prompt class instance before #call.
     # Available in prompt classes: @input, @context, @params, @memory, @context_window, @config
-    def inject_agent_state(obj)
+    def inject_request_state(obj)
       obj.instance_variable_set(:@input,          @input)
       obj.instance_variable_set(:@context,        @context)
       obj.instance_variable_set(:@params,         @params)

data/lib/active_harness/{agent → request}/providers.rb

@@ -1,5 +1,5 @@
 module ActiveHarness
-  class Agent
+  class Request
     # Errors that allow retrying the next model in the chain.
     # InvalidRequestError is included here so that a bad model name (or any
     # per-model request failure) does not abort the entire chain — the next

data/lib/active_harness/{agent → request}/transcription.rb

@@ -1,9 +1,9 @@
 module ActiveHarness
-  class Agent
+  class Request
     class << self
-      # Mark this agent as an audio transcription agent.
+      # Mark this request as an audio transcription request.
       #
-      #   class TranscriptionAgent < ActiveHarness::Agent
+      #   class TranscriptionRequest < ActiveHarness::Request
       #     transcribe true
       #
       #     model do
@@ -16,13 +16,13 @@ module ActiveHarness
       # result.output    — transcribed text (String)
       # result.processed — same as output (format :text default)
       def transcribe(value = true)
-        agent_config[:transcribe] = value
+        request_config[:transcribe] = value
       end
 
-      # Default ISO-639-1 language hint for all models in this agent's chain.
+      # Default ISO-639-1 language hint for all models in this request's chain.
       # Can be overridden per-model via:  use provider: :openrouter, model: "...", language: "ja"
       def language(default_language)
-        agent_config[:transcribe_language] = default_language
+        request_config[:transcribe_language] = default_language
       end
     end
 
@@ -38,7 +38,7 @@ module ActiveHarness
 
     alias_method :_normalize_input_before_transcribe, :normalize_input!
 
-    # @input is a file path for transcription agents, not free text —
+    # @input is a file path for transcription requests, not free text —
     # stripping/collapsing whitespace could corrupt a path. Skip it.
     def normalize_input!
       return if @config[:transcribe]

data/lib/active_harness/{agent.rb → request.rb}

@@ -1,15 +1,15 @@
 require "json"
 
 module ActiveHarness
-  class Agent
+  class Request
     # -------------------------------------------------------------------------
     # Class-level DSL — core
     # -------------------------------------------------------------------------
     class << self
       # Class-level entry point.
       #
-      #   SupportAgent.call(input: "Hi")
-      #   SupportAgent.call(input: "Hi", context: { user_id: 42 })
+      #   SupportRequest.call(input: "Hi")
+      #   SupportRequest.call(input: "Hi", context: { user_id: 42 })
       def call(
         input:   nil,
         context: {},
@@ -31,12 +31,12 @@ module ActiveHarness
       end
 
       # Each subclass gets its own isolated config hash.
-      def agent_config
-        @agent_config ||= {}
+      def request_config
+        @request_config ||= {}
       end
 
       def inherited(subclass)
-        subclass.instance_variable_set(:@agent_config, {})
+        subclass.instance_variable_set(:@request_config, {})
       end
 
       # Automatically strip and collapse whitespace in @input before each call.
@@ -44,7 +44,7 @@ module ActiveHarness
       #
       #   normalize_input false
       def normalize_input(value = true)
-        agent_config[:normalize_input] = value
+        request_config[:normalize_input] = value
       end
     end
 
@@ -74,7 +74,7 @@ module ActiveHarness
       stream:  nil
     )
       @input           = input
-      @config          = self.class.agent_config
+      @config          = self.class.request_config
       normalize_input!
       @context         = context
       @params          = params
@@ -89,8 +89,8 @@ module ActiveHarness
     # Raises Errors::AllModelsFailed if every model in the chain fails.
     #
     # Optionally accepts input and stream callback inline:
-    #   agent.call("What is the capital of Japan?")
-    #   agent.call("...", stream: ->(token) { print token })
+    #   request.call("What is the capital of Japan?")
+    #   request.call("...", stream: ->(token) { print token })
     def call(input = nil, token: nil, stream: nil)
       if input
         @input = input
@@ -205,13 +205,13 @@ module ActiveHarness
   end
 end
 
-require_relative "agent/prompt"
-require_relative "agent/hooks"
-require_relative "agent/models"
-require_relative "agent/providers"
-require_relative "agent/output_parser"
-require_relative "agent/custom_llm_backend"
-require_relative "agent/cost"
-require_relative "agent/image"
-require_relative "agent/transcription"
+require_relative "request/prompt"
+require_relative "request/hooks"
+require_relative "request/models"
+require_relative "request/providers"
+require_relative "request/output_parser"
+require_relative "request/custom_llm_backend"
+require_relative "request/cost"
+require_relative "request/image"
+require_relative "request/transcription"
 

data/lib/active_harness/result.rb

@@ -33,16 +33,16 @@ module ActiveHarness
   # nil when pricing data is unavailable.
   CostBreakdown = Struct.new(:input, :output, :total, keyword_init: true)
 
-  # Combined token + cost stats for a single agent call.
+  # Combined token + cost stats for a single request call.
   # tokens is always present (raw provider data).
   # cost is nil when pricing is unavailable.
   UsageInfo = Struct.new(:tokens, :cost, keyword_init: true)
 
-  # Result returned by Agent#call (accessible via agent.result).
+  # Result returned by Request#call (accessible via request.result).
   #
   #   result.input            — original input string
   #   result.output           — raw string from the provider
-  #   result.processed        — parsed Hash/Array for :json agents, raw string for :text
+  #   result.processed        — parsed Hash/Array for :json requests, raw string for :text
   #   result.system_prompt    — resolved system prompt string
   #   result.model            — ModelInfo (name, provider, temperature, context_window, pricing)
   #   result.model_list       — full model chain proxy

data/lib/active_harness/tribunal/dsl.rb

@@ -1,12 +1,12 @@
 module ActiveHarness
   class Tribunal
     class << self
-      # Declare agents at the class level.
+      # Declare requests at the class level.
       #
-      #   agents PolitenessAgent, ConstructivenessAgent
-      #   agents [PolitenessAgent, ConstructivenessAgent]
-      def agents(*list)
-        tribunal_config[:agents] = list.flatten
+      #   requests PolitenessRequest, ConstructivenessRequest
+      #   requests [PolitenessRequest, ConstructivenessRequest]
+      def requests(*list)
+        tribunal_config[:requests] = list.flatten
       end
 
       # Class-level process block — defines how to compute the verdict from all results.
@@ -25,8 +25,8 @@ module ActiveHarness
       #   :majority   — verdict true when more than half of successful results evaluate to true
       #
       # Options:
-      #   may_fail: N — tolerate up to N agent errors before raising AllAgentsFailed
-      #                 (default: nil — raise only when all agents fail, preserving legacy behavior)
+      #   may_fail: N — tolerate up to N request errors before raising AllRequestsFailed
+      #                 (default: nil — raise only when all requests fail, preserving legacy behavior)
       #
       # The block receives a single Result and must return a truthy/falsy value.
       #

data/lib/active_harness/tribunal/hooks.rb

@@ -2,9 +2,9 @@ module ActiveHarness
   class Tribunal
     VALID_HOOKS = %i[
       before_call
-      before_agent
-      after_agent
-      agent_error
+      before_request
+      after_request
+      request_error
       after_call
       before_verdict
       after_verdict
@@ -14,9 +14,9 @@ module ActiveHarness
       # Class-level hook registration.
       #
       #   on :before_call                  do ... end
-      #   on :before_agent                 do |agent| ... end
-      #   on :after_agent                  do |result| ... end
-      #   on :agent_error                  do |name, error| ... end
+      #   on :before_request               do |request| ... end
+      #   on :after_request                do |result| ... end
+      #   on :request_error                do |name, error| ... end
       #   on :after_call                   do |results, errors| ... end
       #   on :before_verdict               do |results| results end  # transform hook
       #   on :after_verdict                do |verdict| ... end
@@ -32,12 +32,12 @@ module ActiveHarness
       # Rails-style aliases for +on+:
       #
       #   before :call                     do ... end       # → on :before_call
-      #   before :agent                    do |agent| end   # → on :before_agent
+      #   before :request                  do |request| end # → on :before_request
       #   before :verdict                  do |results| end # → on :before_verdict (transform)
       #   after  :call                     do |r, e| end    # → on :after_call
-      #   after  :agent                    do |result| end  # → on :after_agent
+      #   after  :request                  do |result| end  # → on :after_request
       #   after  :verdict                  do |verdict| end # → on :after_verdict
-      #   callback :agent_error            do |name, e| end # → on :agent_error
+      #   callback :request_error          do |name, e| end # → on :request_error
       def before(event, &block)
         on(:"before_#{event}", &block)
       end

data/lib/active_harness/tribunal.rb

@@ -11,19 +11,19 @@ module ActiveHarness
   #
   # Direct usage:
   #   tribunal = ActiveHarness::Tribunal.new(
-  #     input:   "Is this message toxic?",
-  #     context: { user_id: 42 },
-  #     agents:  [ToxicityAgent, BiasAgent, SpamAgent],
-  #     timeout: 7
+  #     input:    "Is this message toxic?",
+  #     context:  { user_id: 42 },
+  #     requests: [ToxicityRequest, BiasRequest, SpamRequest],
+  #     timeout:  7
   #   )
-  #   tribunal.on(:after_agent) { |result| puts result.model }
+  #   tribunal.on(:after_request) { |result| puts result.model }
   #   tribunal.process { |results| results.all? { |r| r.processed["result"] == true } }
   #   tribunal.call
   #
   # Subclass with DSL:
   #   class ContentQualityTribunal < ActiveHarness::Tribunal
-  #     agents PolitenessAgent, ConstructivenessAgent
-  #     on(:after_agent) { |result| puts result.model }
+  #     requests PolitenessRequest, ConstructivenessRequest
+  #     on(:after_request) { |result| puts result.model }
   #     process { |results| results.all? { |r| r.processed["result"] == true } }
   #   end
   #   ContentQualityTribunal.new(input: "...").call
@@ -35,11 +35,11 @@ module ActiveHarness
     class << self
       # Each subclass gets its own isolated config hash.
       def tribunal_config
-        @tribunal_config ||= { agents: [], hooks: {} }
+        @tribunal_config ||= { requests: [], hooks: {} }
       end
 
       def inherited(subclass)
-        subclass.instance_variable_set(:@tribunal_config, { agents: [], hooks: {} })
+        subclass.instance_variable_set(:@tribunal_config, { requests: [], hooks: {} })
       end
     end
 
@@ -54,7 +54,7 @@ module ActiveHarness
                   :errors,
                   :verdict,
                   :execution_time,
-                  :agent_execution_times,
+                  :request_execution_times,
                   :token,
                   :stream
 
@@ -63,7 +63,7 @@ module ActiveHarness
       context:  {},
       params:   {},
       memory:   nil,
-      agents:   nil,
+      requests: nil,
       timeout:  7,
       token:    nil,
       stream:   nil,
@@ -71,28 +71,28 @@ module ActiveHarness
     )
       config = self.class.tribunal_config
 
-      @input                 = input
-      @context               = context
-      @params                = params
-      @memory                = memory
-      @agents                = agents || config[:agents]
-      @timeout               = timeout
-      @process_block         = config[:process]
-      @strategy              = config[:strategy]
-      @evaluate_block        = config[:evaluate_block]
-      @may_fail              = may_fail == :_unset ? config[:may_fail] : may_fail
-      @hooks                 = config[:hooks].transform_values { |v| Array(v).dup }
-      @token                 = token
-      @stream                = stream
-      @results               = []
-      @errors                = []
-      @verdict               = nil
-      @execution_time        = nil
-      @agent_execution_times = []
+      @input                   = input
+      @context                 = context
+      @params                  = params
+      @memory                  = memory
+      @requests                = requests || config[:requests]
+      @timeout                 = timeout
+      @process_block           = config[:process]
+      @strategy                = config[:strategy]
+      @evaluate_block          = config[:evaluate_block]
+      @may_fail                = may_fail == :_unset ? config[:may_fail] : may_fail
+      @hooks                   = config[:hooks].transform_values { |v| Array(v).dup }
+      @token                   = token
+      @stream                  = stream
+      @results                 = []
+      @errors                  = []
+      @verdict                 = nil
+      @execution_time          = nil
+      @request_execution_times = []
     end
 
     # Returns a Result with processed: { "verdict" => @verdict } so the pipeline
-    # can handle agents and tribunals through the same interface.
+    # can handle requests and tribunals through the same interface.
     def result
       Result.new(
         input:          @input,
@@ -102,55 +102,55 @@ module ActiveHarness
       )
     end
 
-    # Run all agents in parallel, then compute the verdict.
+    # Run all requests in parallel, then compute the verdict.
     # Returns self so calls can be chained: tribunal.call.verdict
     #
     # Accepts an optional input to update payload before running — matches
-    # the Agent#call(input) interface so tribunals work as pipeline executors.
+    # the Request#call(input) interface so tribunals work as pipeline executors.
     #
     # Behaviour on failure:
-    #   - If some agents fail/timeout, their errors are in #errors and
+    #   - If some requests fail/timeout, their errors are in #errors and
     #     #results contains only successful results.
-    #   - If ALL agents fail/timeout, raises Errors::AllAgentsFailed.
+    #   - If ALL requests fail/timeout, raises Errors::AllRequestsFailed.
     def call(input = nil, token: nil, stream: nil)
       @input  = input  if input
       @token  = token  if token
       @stream = stream if stream
-      agents = resolve_agents
+      requests = resolve_requests
       fire(:before_call)
 
       started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
-      futures = agents.each_with_index.map do |agent, index|
-        fire(:before_agent, agent, index)
+      futures = requests.each_with_index.map do |request, index|
+        fire(:before_request, request, index)
         t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        future = Concurrent::Future.execute { agent.call }
+        future = Concurrent::Future.execute { request.call }
         [future, t0]
       end
 
-      @results               = []
-      @errors                = []
-      @agent_execution_times = []
+      @results                 = []
+      @errors                  = []
+      @request_execution_times = []
 
       futures.each_with_index do |(future, t0), index|
         future.wait(@timeout)
         elapsed = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0).round(3)
-        @agent_execution_times << { agent: agents[index].class.name, time: elapsed }
+        @request_execution_times << { request: requests[index].class.name, time: elapsed }
 
         if future.fulfilled?
           value  = future.value
-          result = value.is_a?(ActiveHarness::Agent) ? value.result : value
+          result = value.is_a?(ActiveHarness::Request) ? value.result : value
           @results << result
-          fire(:after_agent, result, index)
+          fire(:after_request, result, index)
         elsif future.incomplete?
           error = Errors::TimeoutError.new(
-            "Agent #{agents[index].class.name} timed out after #{@timeout}s"
+            "Request #{requests[index].class.name} timed out after #{@timeout}s"
           )
-          @errors << { agent: agents[index].class.name, error: error }
-          fire(:agent_error, agents[index].class.name, error, index)
+          @errors << { request: requests[index].class.name, error: error }
+          fire(:request_error, requests[index].class.name, error, index)
         else
-          @errors << { agent: agents[index].class.name, error: future.reason }
-          fire(:agent_error, agents[index].class.name, future.reason, index)
+          @errors << { request: requests[index].class.name, error: future.reason }
+          fire(:request_error, requests[index].class.name, future.reason, index)
         end
       end
 
@@ -158,7 +158,7 @@ module ActiveHarness
 
       fire(:after_call, @results, @errors)
 
-      # If all agents failed, raise an exception.
+      # If all requests failed, raise an exception.
       # Otherwise, compute the verdict based on successful results.
       check_failure_threshold!
 
@@ -174,26 +174,26 @@ module ActiveHarness
 
     def check_failure_threshold!
       if !@may_fail.nil? && @errors.size > @may_fail
-        raise Errors::AllAgentsFailed,
-          "Too many agents failed (#{@errors.size} > may_fail: #{@may_fail}) — #{error_summary}"
+        raise Errors::AllRequestsFailed,
+          "Too many requests failed (#{@errors.size} > may_fail: #{@may_fail}) — #{error_summary}"
       elsif @results.empty?
-        raise Errors::AllAgentsFailed, "All agents failed — #{error_summary}"
+        raise Errors::AllRequestsFailed, "All requests failed — #{error_summary}"
       end
     end
 
     def error_summary
-      @errors.map { |e| "#{e[:agent]}: #{e[:error].message}" }.join("; ")
+      @errors.map { |e| "#{e[:request]}: #{e[:error].message}" }.join("; ")
     end
 
-    def resolve_agents
-      @agents.map do |agent|
-        if agent.is_a?(Class)
-          agent.new(input: @input, context: @context.dup, params: @params, token: @token, stream: @stream)
+    def resolve_requests
+      @requests.map do |request|
+        if request.is_a?(Class)
+          request.new(input: @input, context: @context.dup, params: @params, token: @token, stream: @stream)
         else
-          agent.input = @input if @input
-          agent.instance_variable_set(:@token,  @token)  if @token
-          agent.instance_variable_set(:@stream, @stream) if @stream
-          agent
+          request.input = @input if @input
+          request.instance_variable_set(:@token,  @token)  if @token
+          request.instance_variable_set(:@stream, @stream) if @stream
+          request
         end
       end
     end

data/lib/active_harness.rb

@@ -27,14 +27,14 @@ require_relative "active_harness/providers/audio/openai"
 require_relative "active_harness/providers/audio/openrouter"
 require "active_harness_pricing"
 require_relative "active_harness/memory"
-require_relative "active_harness/agent"
+require_relative "active_harness/request"
 require_relative "active_harness/tribunal"
 require_relative "active_harness/pipeline"
 
 require_relative "active_harness/railtie" if defined?(Rails::Railtie)
 
 module ActiveHarness
-  VERSION = "0.2.42"
+  VERSION = "0.3.0"
 
   class << self
     # Configure ActiveHarness.

data/lib/generators/active_harness/install/install_generator.rb

@@ -7,7 +7,7 @@ module ActiveHarness
 
       source_root File.expand_path("templates", __dir__)
 
-      APP_AI_DIRS = %w[agents prompts tribunals pipelines memory].freeze
+      APP_AI_DIRS = %w[requests prompts tribunals pipelines memory].freeze
 
       def create_structure
         APP_AI_DIRS.each do |dir|

data/lib/generators/active_harness/install/templates/controllers/ai_controller.rb

@@ -8,7 +8,7 @@ class AiSupportController < ApplicationController
   # body: { input: "What is your return policy?" }
   # ---------------------------------------------------------------------------
   def agent
-    result = SupportAgent.call(input: params.require(:input))
+    result = SupportRequest.call(input: params.require(:input))
 
     render json: {
       output: result.output,
@@ -26,7 +26,7 @@ class AiSupportController < ApplicationController
   # ---------------------------------------------------------------------------
   def agent_memory
     memory = AppMemory.new(session_id: params.require(:session_id))
-    result = SupportAgent.call(input: params.require(:input), memory: memory)
+    result = SupportRequest.call(input: params.require(:input), memory: memory)
 
     render json: {
       output: result.output,
@@ -94,7 +94,7 @@ class AiSupportController < ApplicationController
 
     sse = ActionController::Live::SSE.new(response.stream, event: "message")
 
-    SupportAgent.call(
+    SupportRequest.call(
       input:  input,
       stream: ->(token) { sse.write({ token: token }.to_json) }
     )