active_harness 0.2.35 → 0.2.37

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f08d4dd9d2254cb4895919e690fd485cab05d2b89c53786383b0da353aeb5f82
-  data.tar.gz: 1aa9a3e3a7cd8a2e83179b88a9f3623f39b4fa59e7386d43094de2739f44d50a
+  metadata.gz: 5fb1f238ea442c93d556e18ef1b899ad8d8e8345c6ed18c8abd0d45370c847e0
+  data.tar.gz: 8c8b0dceb9c779f6432dc86f141fdda65144b365511ee3096957a96954447b4e
 SHA512:
-  metadata.gz: 1aa38c722c75fbc04d6d389ebe6d260322eddd1a4d6c5bb9a43117b2b341447bf1883f90beacdcf5c2bc99adc6867a2dc7ee820f3dcd85d44538c5d148953a92
-  data.tar.gz: 146bf3d9516d70dcc45c2b092855b2b6b01543dd3b76e45de250b2b91fecce700cbabf7f492ebbf2e7417dfca22a48c21b2247a361b83eb28a81b001a3ce5999
+  metadata.gz: fd1da6cb093ea99b414576fe9e1fc2ec0fee4a894eca5bd5291582ea5daabdb1ee621f22a5b7e4460455c03fd47df5b152b5d9598c64df9a408cbaec93ca3371
+  data.tar.gz: 939c5d39b1f172ae0225087f095e8665c84b34f6cc384bf2e8f949e871a0be63c3ecf59253e253a1066c40c6c41528f57c8b09790720dca765c8760175ce36ad

data/lib/active_harness/agent/custom_llm_backend.rb

@@ -54,8 +54,8 @@ module ActiveHarness
       chat = backend.call(params)
       chat.with_instructions(system_prompt) if system_prompt
 
-      if @token_stream
-        response = chat.ask(@input) { |chunk| @token_stream.call(chunk.content) if chunk.content }
+      if @token
+        response = chat.ask(@input) { |chunk| @token.call(chunk.content) if chunk.content }
       else
         response = chat.ask(@input)
       end

data/lib/active_harness/agent/hooks.rb

@@ -67,11 +67,9 @@ module ActiveHarness
       run_hooks(@config[:hooks] || {}, event, *args)
     end
 
-    # Unified internal method: fires the DSL hook AND the external event_stream lambda.
-    # Consistent with Tribunal#fire and Pipeline#fire.
     def fire(event, *args)
       run_hook(event, *args)
-      @event_stream&.call(event, *args)
+      @stream&.call(:agent, event, *args)
     rescue IOError, ActionController::Live::ClientDisconnected
     end
   end

data/lib/active_harness/agent/providers.rb

@@ -53,7 +53,7 @@ module ActiveHarness
       messages = build_messages(system_prompt, @input)
       opts = { model: entry[:model], messages: messages }
       opts[:temperature] = entry[:temperature] if entry[:temperature]
-      opts[:stream]      = @token_stream       if @token_stream
+      opts[:stream]      = @token               if @token
       opts[:name]        = entry[:name]        if entry[:name]
       provider.call(**opts)
     end

data/lib/active_harness/agent.rb

@@ -16,7 +16,8 @@ module ActiveHarness
         params:  {},
         memory:  nil,
         models:  nil,
-        streams: {}
+        token:   nil,
+        stream:  nil
       )
         new(
           input:   input,
@@ -24,7 +25,8 @@ module ActiveHarness
           params:  params,
           memory:  memory,
           models:  models,
-          streams: streams
+          token:   token,
+          stream:  stream
         ).call
       end
 
@@ -54,8 +56,8 @@ module ActiveHarness
                   :params,
                   :memory
     attr_reader   :result,
-                  :token_stream,
-                  :event_stream
+                  :token,
+                  :stream
 
     def models=(list)
       @models_override = Array(list)
@@ -68,7 +70,8 @@ module ActiveHarness
       params:  {},
       memory:  nil,
       models:  nil,
-      streams: {}
+      token:   nil,
+      stream:  nil
     )
       @input           = input
       @config          = self.class.agent_config
@@ -77,8 +80,8 @@ module ActiveHarness
       @params          = params
       @memory          = memory
       @models_override = Array(models) if models
-      @token_stream    = streams[:token]
-      @event_stream     = streams[:agent]
+      @token           = token
+      @stream          = stream
       fire(:setup)
     end
 
@@ -88,15 +91,13 @@ module ActiveHarness
     # Optionally accepts input and stream callback inline:
     #   agent.call("What is the capital of Japan?")
     #   agent.call("...", stream: ->(token) { print token })
-    def call(input = nil, streams: nil)
+    def call(input = nil, token: nil, stream: nil)
       if input
         @input = input
         normalize_input!
       end
-      if streams
-        @token_stream = streams[:token] if streams.key?(:token)
-        @event_stream = streams[:agent] if streams.key?(:agent)
-      end
+      @token  = token  if token
+      @stream = stream if stream
       fire(:before_call)
       @system_prompt = resolve_system_prompt
       attempts = []

data/lib/active_harness/pipeline/hooks.rb

@@ -60,15 +60,14 @@ module ActiveHarness
 
     private
 
-    # Fires global hook AND pipeline_event_stream. Consistent with Agent#fire and Tribunal#fire.
     def fire(event, step_name, data, config)
       run_hooks(config[:hooks], event, step_name, data)
-      @pipeline_event_stream&.call(event, step_name, data)
+      @stream&.call(:pipeline, event, step_name, data)
     rescue IOError, ActionController::Live::ClientDisconnected
       nil
     end
 
-    # Per-step hook: receives (data) only — not forwarded to pipeline_event_stream
+    # Per-step hook: receives (data) only — not forwarded to stream
     # (global fire already covers the step event with step_name context).
     def fire_step(event, step_name, data, config)
       run_hooks(config[:step_hooks][step_name] || {}, event, data)

data/lib/active_harness/pipeline.rb

@@ -66,8 +66,7 @@ module ActiveHarness
       # any agent or tribunal executed within this pipeline (including agents
       # running inside tribunals). Multiple blocks can be registered; all fire.
       #
-      # The handler receives the same (event, *args) signature that the runtime
-      # streams: { agent: lambda } would receive.
+      # The handler receives (event, *args) — already scoped to the source.
       #
       #   on_agent_event do |event, result|
       #     Rails.logger.info "[Agent #{event}] #{result.model}" if event == :after_call
@@ -116,24 +115,23 @@ module ActiveHarness
       context: {},
       params:  {},
       memory:  nil,
-      streams: {}
+      token:   nil,
+      stream:  nil
     )
-      @original_input        = input
-      @payload               = input
-      @context               = context.dup
-      @params                = params
-      @memory                = memory
-      @token_stream          = streams[:token]
-      class_streams          = self.class.pipeline_config[:streams] || {}
-      @agent_event_stream    = merge_stream(streams[:agent],    class_streams[:agent])
-      @tribunal_event_stream = merge_stream(streams[:tribunal], class_streams[:tribunal])
-      @pipeline_event_stream = merge_stream(streams[:pipeline], class_streams[:pipeline])
-      @step_results          = {}
-      @stopped               = false
-      @stopped_at            = nil
-      @stop_reason           = nil
-      @execution_time        = nil
-      @output                = nil
+      @original_input = input
+      @payload        = input
+      @context        = context.dup
+      @params         = params
+      @memory         = memory
+      @token          = token
+      class_streams   = self.class.pipeline_config[:streams] || {}
+      @stream         = merge_stream(stream, class_streams)
+      @step_results   = {}
+      @stopped        = false
+      @stopped_at     = nil
+      @stop_reason    = nil
+      @execution_time = nil
+      @output         = nil
     end
 
     def stopped?
@@ -179,7 +177,7 @@ module ActiveHarness
           @stopped_at  = step.name
           @stop_reason = result
           run_hooks(config[:hooks], :stopped, step.name, result)
-          @pipeline_event_stream&.call(:stopped, step.name, result)
+          @stream&.call(:pipeline, :stopped, step.name, result)
           break
         end
       end
@@ -196,7 +194,7 @@ module ActiveHarness
 
         last_result = @step_results[@step_results.keys.last]
         run_hooks(config[:hooks], :complete, last_result)
-        @pipeline_event_stream&.call(:complete, last_result)
+        @stream&.call(:pipeline, :complete, last_result)
       end
 
       self
@@ -204,37 +202,41 @@ module ActiveHarness
 
     private
 
-    # Combines a runtime-passed stream lambda with zero or more class-level handler
-    # blocks registered via on_agent_event / on_tribunal_event / on_pipeline_event.
-    # Returns nil when there are no handlers at all, preserving the existing
-    # "no stream" fast path in agents and tribunals.
+    # Combines a runtime-passed stream lambda with class-level handler blocks
+    # registered via on_agent_event / on_tribunal_event / on_pipeline_event.
+    # Returns nil when there are no handlers at all.
     #
-    # Each class-level handler is evaluated via instance_exec so that blocks
-    # written in the pipeline class body can access pipeline instance variables
-    # (e.g. @otel_pipeline_span, @params) and call pipeline instance methods.
+    # Class-level handlers receive (event, *args) — already scoped to source.
+    # Runtime lambda receives (source, event, *args).
+    # instance_exec lets class-level blocks access pipeline instance variables.
     def merge_stream(passed_in, class_handlers)
-      class_handlers = Array(class_handlers).compact
-      return passed_in if class_handlers.empty?
+      agent_handlers    = Array(class_handlers[:agent]).compact
+      tribunal_handlers = Array(class_handlers[:tribunal]).compact
+      pipeline_handlers = Array(class_handlers[:pipeline]).compact
+
+      has_class_handlers = agent_handlers.any? || tribunal_handlers.any? || pipeline_handlers.any?
+      return passed_in unless has_class_handlers
 
       pipeline_instance = self
-      ->(event, *args) {
-        class_handlers.each { |h| pipeline_instance.instance_exec(event, *args, &h) }
-        passed_in&.call(event, *args)
+      ->(source, event, *args) {
+        handlers = case source
+                   when :agent    then agent_handlers
+                   when :tribunal then tribunal_handlers
+                   when :pipeline then pipeline_handlers
+                   else                []
+                   end
+        handlers.each { |h| pipeline_instance.instance_exec(event, *args, &h) }
+        passed_in&.call(source, event, *args)
       }
     end
 
     def execute_step(step)
-      streams = {
-        token:    @token_stream,
-        agent:    @agent_event_stream,
-        tribunal: @tribunal_event_stream,
-        pipeline: @pipeline_event_stream
-      }.compact
       step.agent_class.new(
         input:   @payload,
         context: @context.dup,
         params:  @params,
-        streams: streams
+        token:   @token,
+        stream:  @stream
       ).call.result
     end
   end

data/lib/active_harness/tribunal/hooks.rb

@@ -72,10 +72,9 @@ module ActiveHarness
       run_hooks(@hooks, event, *args)
     end
 
-    # Fire the DSL-registered hook AND the external tribunal_event_stream lambda (if set).
     def fire(event, *args)
       run_hook(event, *args)
-      @tribunal_event_stream&.call(event, *args)
+      @stream&.call(:tribunal, event, *args)
     rescue IOError, ActionController::Live::ClientDisconnected
       nil
     end

data/lib/active_harness/tribunal.rb

@@ -55,9 +55,8 @@ module ActiveHarness
                   :verdict,
                   :execution_time,
                   :agent_execution_times,
-                  :token_stream,
-                  :agent_event_stream,
-                  :tribunal_event_stream
+                  :token,
+                  :stream
 
     def initialize(
       input:    nil,
@@ -66,7 +65,8 @@ module ActiveHarness
       memory:   nil,
       agents:   nil,
       timeout:  7,
-      streams:  {},
+      token:    nil,
+      stream:   nil,
       may_fail: :_unset
     )
       config = self.class.tribunal_config
@@ -82,9 +82,8 @@ module ActiveHarness
       @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_stream          = streams[:token]
-      @agent_event_stream    = streams[:agent]
-      @tribunal_event_stream = streams[:tribunal]
+      @token                 = token
+      @stream                = stream
       @results               = []
       @errors                = []
       @verdict               = nil
@@ -181,14 +180,13 @@ module ActiveHarness
     end
 
     def resolve_agents
-      agent_streams = { token: @token_stream, agent: @agent_event_stream }.compact
       @agents.map do |agent|
         if agent.is_a?(Class)
-          agent.new(input: @input, context: @context.dup, params: @params, streams: agent_streams)
+          agent.new(input: @input, context: @context.dup, params: @params, token: @token, stream: @stream)
         else
           agent.input = @input if @input
-          agent.instance_variable_set(:@token_stream, @token_stream) if @token_stream
-          agent.instance_variable_set(:@event_stream, @agent_event_stream) if @agent_event_stream
+          agent.instance_variable_set(:@token,  @token)  if @token
+          agent.instance_variable_set(:@stream, @stream) if @stream
           agent
         end
       end

data/lib/active_harness.rb

@@ -23,9 +23,7 @@ require_relative "active_harness/providers/vertexai"
 require_relative "active_harness/providers/custom"
 require_relative "active_harness/providers/images/openai"
 require_relative "active_harness/providers/images/openrouter"
-require_relative "active_harness/pricing"
-require_relative "active_harness/pricing/models_dev"
-require_relative "active_harness/pricing/openrouter"
+require "active_harness_pricing"
 require_relative "active_harness/memory"
 require_relative "active_harness/agent"
 require_relative "active_harness/tribunal"
@@ -34,7 +32,7 @@ require_relative "active_harness/pipeline"
 require_relative "active_harness/railtie" if defined?(Rails::Railtie)
 
 module ActiveHarness
-  VERSION = "0.2.35"
+  VERSION = "0.2.37"
 
   class << self
     # Configure ActiveHarness.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_harness
 version: !ruby/object:Gem::Version
-  version: 0.2.35
+  version: 0.2.37
 platform: ruby
 authors:
 - the-teacher
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-06-13 00:00:00.000000000 Z
+date: 2026-06-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: active_harness_pricing
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - the-teacher@github.com
@@ -56,9 +70,6 @@ files:
 - lib/active_harness/pipeline/README.md
 - lib/active_harness/pipeline/hooks.rb
 - lib/active_harness/pipeline/step.rb
-- lib/active_harness/pricing.rb
-- lib/active_harness/pricing/models_dev.rb
-- lib/active_harness/pricing/openrouter.rb
 - lib/active_harness/providers/PROVIDER_CONTRACT.md
 - lib/active_harness/providers/anthropic.rb
 - lib/active_harness/providers/azure.rb

data/lib/active_harness/pricing/models_dev.rb

@@ -1,218 +0,0 @@
-require "json"
-require "net/http"
-require "uri"
-require "fileutils"
-require "set"
-
-module ActiveHarness
-  module Pricing
-    # Fallback pricing source — fetches model data from models.dev.
-    #
-    # Data source:
-    #   {project_root}/tmp/active_harness/pricing_models_dev.json — fetched cache (24h TTL)
-    #   Returns nil/empty if cache is missing and network is unavailable.
-    #
-    # Usage:
-    #   Pricing::ModelsDev.find("gpt-4o")
-    #   Pricing::ModelsDev.all
-    #   Pricing::ModelsDev.update
-    module ModelsDev
-      MODELS_DEV_URL = "https://models.dev/api.json"
-      MEMORY_TTL     = 3 * 86_400  # 3 days
-
-      MODELS_DEV_PROVIDER_MAP = {
-        "openai"         => "openai",
-        "anthropic"      => "anthropic",
-        "google"         => "gemini",
-        "google-vertex"  => "vertexai",
-        "amazon-bedrock" => "bedrock",
-        "deepseek"       => "deepseek",
-        "mistral"        => "mistral",
-        "openrouter"     => "openrouter",
-        "perplexity"     => "perplexity",
-        "xai"            => "xai",
-        "groq"           => "groq",
-        "azure"          => "azure"
-      }.freeze
-
-      class << self
-        def all
-          ensure_fresh_registry
-          registry.map { |raw| build_cost(raw) }
-        end
-
-        def find(model_id)
-          ensure_fresh_registry
-          raw = registry.find { |m| m[:id] == model_id.to_s }
-          raw ? build_cost(raw) : nil
-        end
-
-        def providers
-          @providers_proxy ||= Pricing::ProvidersProxy.new(self)
-        end
-
-        def for_provider(name)
-          ensure_fresh_registry
-          registry
-            .select { |m| m[:provider] == name.to_s }
-            .map { |m| build_cost(m) }
-        end
-
-        def provider_names
-          @provider_names ||= begin
-            ensure_fresh_registry
-            registry.map { |m| m[:provider] }.uniq.sort
-          end
-        end
-
-        # Fetches fresh data from models.dev, writes to cache file, loads into memory.
-        # Called automatically when memory is stale. Can also be called explicitly.
-        def preload!
-          update
-        rescue StandardError
-          nil
-        ensure
-          @registry   = load_registry
-          @loaded_at  = @registry.empty? ? nil : Time.now
-          @provider_names = nil
-        end
-
-        def update
-          raw_api = fetch_models_dev
-          models  = extract_models(raw_api)
-
-          FileUtils.mkdir_p(File.dirname(cache_file))
-          File.write(cache_file, JSON.generate(models))
-          models.size
-        end
-
-        def reload!
-          @registry       = nil
-          @loaded_at      = nil
-          @provider_names = nil
-          nil
-        end
-
-        def cache_file
-          File.join(project_root, "tmp", "active_harness", "models_dev_pricing.json")
-        end
-
-        def available_providers
-          @available_providers ||= begin
-            providers_dir = File.expand_path("../providers", __dir__)
-            Dir.glob("#{providers_dir}/*.rb")
-              .map { |f| File.basename(f, ".rb") }
-              .reject { |n| %w[base custom].include?(n) }
-          end
-        end
-
-        private
-
-        def ensure_fresh_registry
-          return if memory_fresh?
-
-          unless file_fresh?
-            begin
-              update
-            rescue StandardError
-              nil
-            end
-          end
-
-          @registry       = load_registry
-          @loaded_at      = @registry.empty? ? nil : Time.now
-          @provider_names = nil
-        end
-
-        def memory_fresh?
-          @loaded_at && (Time.now - @loaded_at) < MEMORY_TTL
-        end
-
-        def file_fresh?
-          File.exist?(cache_file) && (Time.now - File.mtime(cache_file)) < MEMORY_TTL
-        end
-
-        def registry
-          @registry ||= []
-        end
-
-        def load_registry
-          return [] unless File.exist?(cache_file)
-          data = JSON.parse(File.read(cache_file), symbolize_names: true)
-          data.is_a?(Array) ? data : []
-        rescue JSON::ParserError
-          []
-        end
-
-        def fetch_models_dev
-          uri      = URI(MODELS_DEV_URL)
-          response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |http|
-            http.get(uri.request_uri)
-          end
-          raise "models.dev returned HTTP #{response.code}" unless response.is_a?(Net::HTTPSuccess)
-
-          JSON.parse(response.body, symbolize_names: true)
-        end
-
-        def extract_models(raw_api)
-          allowed = available_providers.to_set
-
-          raw_api.flat_map do |provider_key, provider_data|
-            ah_provider = MODELS_DEV_PROVIDER_MAP[provider_key.to_s]
-            next [] unless ah_provider && allowed.include?(ah_provider)
-
-            models_hash = provider_data.is_a?(Hash) ? (provider_data[:models] || {}) : {}
-            models_hash.values.filter_map do |m|
-              next unless m.is_a?(Hash) && m[:id]
-
-              cost     = m[:cost] || {}
-              standard = {
-                input_per_million:             cost[:input],
-                output_per_million:            cost[:output],
-                cache_read_input_per_million:  cost[:cache_read],
-                cache_write_input_per_million: cost[:cache_write]
-              }.compact
-
-              mods = m[:modalities] || {}
-              {
-                id:                m[:id],
-                name:              m[:name] || m[:id],
-                provider:          ah_provider,
-                context_window:    m[:context_window] || m.dig(:limit, :context),
-                max_output_tokens: m[:max_output_tokens] || m.dig(:limit, :output),
-                input_modalities:  Array(mods[:input]),
-                output_modalities: Array(mods[:output]),
-                pricing:           standard.any? ? { text_tokens: { standard: standard } } : {}
-              }
-            end
-          end
-        end
-
-        def build_cost(raw)
-          standard = raw.dig(:pricing, :text_tokens, :standard) || {}
-          Pricing::ModelPrice.new(
-            id:                            raw[:id],
-            name:                          raw[:name],
-            provider:                      raw[:provider],
-            input_per_million:             standard[:input_per_million],
-            output_per_million:            standard[:output_per_million],
-            cache_read_input_per_million:  standard[:cache_read_input_per_million],
-            cache_write_input_per_million: standard[:cache_write_input_per_million],
-            context_window:                raw[:context_window],
-            max_output_tokens:             raw[:max_output_tokens],
-            input_modalities:              Array(raw[:input_modalities]),
-            output_modalities:             Array(raw[:output_modalities])
-          )
-        end
-
-        def project_root
-          if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
-            Rails.root.to_s
-          else
-            Dir.pwd
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_harness/pricing/openrouter.rb

@@ -1,323 +0,0 @@
-require "json"
-require "net/http"
-require "uri"
-require "fileutils"
-
-module ActiveHarness
-  module Pricing
-    # Fetches complete pricing for all OpenRouter models across all modalities.
-    #
-    # OpenRouter exposes models via several endpoints:
-    #   GET /api/v1/models                          → 337 text models (base)
-    #   GET /api/v1/models?output_modalities=image  → 32 image-gen models (25 extra)
-    #   GET /api/v1/models?output_modalities=embeddings    → 26 models (all extra)
-    #   GET /api/v1/models?output_modalities=speech        →  9 models (all extra)
-    #   GET /api/v1/models?output_modalities=transcription → 10 models (all extra)
-    #   GET /api/v1/models?output_modalities=video         → 14 models (all zero pricing)
-    #   GET /api/v1/models?output_modalities=rerank        →  4 models (all zero pricing)
-    #
-    # For image-output models, /api/v1/models/{id}/endpoints is also fetched
-    # to get the accurate `image_output` per-token rate.
-    #
-    # All models are merged by id; pricing fields are populated per-modality:
-    #   text_input / text_output — text tokens
-    #   image_input              — image tokens accepted as input (vision)
-    #   image_output             — image generation tokens (from /endpoints)
-    #   audio_input              — audio tokens as input
-    #   audio_output             — audio tokens as output (TTS)
-    #   cache_read / cache_write — cache tokens
-    #   web_search               — per web-search request
-    #
-    # Usage:
-    #   Pricing::OpenRouter.find("openai/gpt-5-image-mini")  # → ModelPrice or nil
-    #   Pricing::OpenRouter.all                              # → Array<ModelPrice>
-    #   Pricing::OpenRouter.update                           # force refresh
-    module OpenRouter
-      API_BASE   = "https://openrouter.ai/api/v1/models"
-      MEMORY_TTL = 3 * 86_400  # 3 days
-
-      # Modalities that have models outside the base text-337 set.
-      EXTRA_MODALITIES = %w[image embeddings speech transcription video rerank].freeze
-
-      class << self
-        def find(model_id)
-          ensure_fresh_registry
-          raw = registry.find { |m| m[:id] == model_id.to_s }
-          raw ? build_price(raw) : nil
-        end
-
-        def all
-          ensure_fresh_registry
-          registry.filter_map { |raw| build_price(raw) }
-        end
-
-        def preload!
-          update
-        rescue StandardError
-          nil
-        ensure
-          @registry  = load_registry
-          @loaded_at = @registry.empty? ? nil : Time.now
-        end
-
-        def update
-          entries = collect_all_models
-          FileUtils.mkdir_p(File.dirname(cache_file))
-          File.write(cache_file, JSON.generate(entries))
-          entries.size
-        end
-
-        def reload!
-          @registry  = nil
-          @loaded_at = nil
-        end
-
-        def cache_file
-          File.join(project_root, "tmp", "active_harness", "openrouter_pricing.json")
-        end
-
-        private
-
-        # ── Freshness ────────────────────────────────────────────────────
-
-        def ensure_fresh_registry
-          return if memory_fresh?
-          unless file_fresh?
-            begin
-              update
-            rescue StandardError
-              nil
-            end
-          end
-          @registry  = load_registry
-          @loaded_at = @registry.empty? ? nil : Time.now
-        end
-
-        def memory_fresh?
-          @loaded_at && (Time.now - @loaded_at) < MEMORY_TTL
-        end
-
-        def file_fresh?
-          File.exist?(cache_file) && (Time.now - File.mtime(cache_file)) < MEMORY_TTL
-        end
-
-        def registry
-          @registry ||= []
-        end
-
-        def load_registry
-          return [] unless File.exist?(cache_file)
-          data = JSON.parse(File.read(cache_file), symbolize_names: true)
-          data.is_a?(Array) ? data : []
-        rescue JSON::ParserError
-          []
-        end
-
-        # ── Data collection ──────────────────────────────────────────────
-
-        # Fetches all modality endpoints, merges by id, enriches image models.
-        def collect_all_models
-          models = {}
-
-          # Base text models
-          fetch_models(API_BASE).each do |m|
-            models[m[:id]] = normalize(m)
-          end
-
-          # Specialized modalities — add extra models and merge pricing
-          EXTRA_MODALITIES.each do |mod|
-            fetch_models("#{API_BASE}?output_modalities=#{mod}").each do |m|
-              id = m[:id]
-              if models[id]
-                merge_pricing!(models[id], m)
-              else
-                models[id] = normalize(m)
-              end
-            end
-          end
-
-          # Enrich image-output models with /endpoints for accurate image_output rate
-          models.values.map do |entry|
-            if Array(entry[:output_modalities]).include?("image")
-              enrich_with_endpoint(entry)
-            else
-              entry
-            end
-          end
-        end
-
-        # Normalize a raw API model hash into our cache entry format.
-        def normalize(m)
-          p = m[:pricing] || {}
-          {
-            id:                m[:id],
-            name:              m[:name],
-            input_modalities:  m.dig(:architecture, :input_modalities)  || [],
-            output_modalities: m.dig(:architecture, :output_modalities) || [],
-            text_input:        p[:prompt].to_s,
-            text_output:       p[:completion].to_s,
-            image_input:       p[:image].to_s,
-            audio_input:       p[:audio].to_s,
-            image_output:      "",
-            audio_output:      "",
-            cache_read:        p[:input_cache_read].to_s,
-            cache_write:       p[:input_cache_write].to_s,
-            web_search:        p[:web_search].to_s
-          }
-        end
-
-        # Merge non-zero pricing fields from a new API response into existing entry.
-        def merge_pricing!(entry, raw_model)
-          p = raw_model[:pricing] || {}
-          [
-            [:text_input,  p[:prompt]],
-            [:text_output, p[:completion]],
-            [:image_input, p[:image]],
-            [:audio_input, p[:audio]],
-            [:cache_read,  p[:input_cache_read]],
-            [:cache_write, p[:input_cache_write]],
-            [:web_search,  p[:web_search]]
-          ].each do |key, val|
-            entry[key] = val.to_s if val.to_f > 0 && entry[key].to_f == 0
-          end
-
-          # Merge modalities (union)
-          new_out = raw_model.dig(:architecture, :output_modalities) || []
-          entry[:output_modalities] = (Array(entry[:output_modalities]) | new_out).uniq
-          new_in  = raw_model.dig(:architecture, :input_modalities)  || []
-          entry[:input_modalities]  = (Array(entry[:input_modalities])  | new_in).uniq
-        end
-
-        # Fetch /endpoints and add image_output rate to the entry.
-        def enrich_with_endpoint(entry)
-          pricing = fetch_endpoint_pricing(entry[:id])
-          entry[:image_output] = pricing&.dig(:image_output).to_s
-          entry[:audio_output] = pricing&.dig(:audio_output).to_s
-          entry
-        rescue StandardError
-          entry
-        end
-
-        def fetch_endpoint_pricing(model_id)
-          uri = URI("#{API_BASE}/#{model_id}/endpoints")
-          resp = http_get(uri)
-          data = JSON.parse(resp.body, symbolize_names: true)
-          endpoints = data.dig(:data, :endpoints) || []
-          ep = endpoints.find { |e| e[:status] == 0 } || endpoints.first
-          ep&.dig(:pricing)
-        rescue StandardError
-          nil
-        end
-
-        def fetch_models(url)
-          resp = http_get(URI(url))
-          data = JSON.parse(resp.body, symbolize_names: true)
-          data[:data] || []
-        end
-
-        # ── Build ModelPrice ─────────────────────────────────────────────
-
-        def build_price(raw)
-          out_mods = Array(raw[:output_modalities])
-          inp_mods = Array(raw[:input_modalities])
-
-          is_imggen        = out_mods.include?("image")
-          is_embed         = out_mods.include?("embeddings")
-          is_speech        = out_mods.include?("speech")
-          is_transcription = out_mods.include?("transcription")
-
-          text_in_pm  = to_pm(raw[:text_input])
-          text_out_pm = to_pm(raw[:text_output])
-          img_in_pm   = to_pm(raw[:image_input])
-          img_out_pm  = to_pm(raw[:image_output])
-          # p[:audio] field — audio input tokens (multimodal/embedding models like Gemini)
-          audio_in_pm = to_pm(raw[:audio_input])
-          aud_out_pm  = to_pm(raw[:audio_output])
-          cache_r_pm  = to_pm(raw[:cache_read])
-          cache_w_pm  = to_pm(raw[:cache_write])
-          # web_search is a flat per-request fee in USD, not a per-token rate
-          ws_raw         = raw[:web_search].to_s
-          web_search_usd = ws_raw.empty? ? nil : (ws_raw.to_f > 0 ? ws_raw.to_f : nil)
-
-          # Transcription pricing is stored in `prompt` but the unit differs by model:
-          #   prompt < 0.0001  → per-audio-token  (e.g. gpt-4o-transcribe $2.5/M)  → use to_pm
-          #   prompt >= 0.0001 → per-minute of audio (e.g. Whisper $0.006/min)      → raw USD
-          if is_transcription
-            raw_rate = raw[:text_input].to_s.to_f
-            audio_in_pm = if raw_rate > 0 && raw_rate < 0.0001
-              to_pm(raw[:text_input])    # per-token → convert to per-million
-            elsif raw_rate > 0
-              raw_rate                   # per-minute → keep raw USD value
-            end
-            text_in_pm = nil
-          end
-
-          # Primary output for cost calculation and sorting:
-          # imggen  → image_output rate (from /endpoints)
-          # speech  → audio_output rate (completion is audio)
-          # embed / transcription → no output cost
-          # text    → text_output rate
-          primary_output = if is_imggen
-            img_out_pm || text_out_pm
-          elsif is_speech
-            aud_out_pm || text_out_pm
-          elsif is_embed || is_transcription
-            nil
-          else
-            text_out_pm
-          end
-
-          # Primary input for cost calculation and sorting
-          primary_input = is_transcription ? audio_in_pm : text_in_pm
-
-          # Skip models with no id/name; keep zero-priced models (rerank, video) —
-          # they are real models, just have $0 rates in the OpenRouter API.
-          return nil unless raw[:id] && raw[:name]
-
-          Pricing::ModelPrice.new(
-            id:                           raw[:id],
-            name:                         raw[:name],
-            provider:                     "openrouter",
-            input_per_million:            primary_input,
-            output_per_million:           primary_output,
-            cache_read_input_per_million: cache_r_pm,
-            cache_write_input_per_million: cache_w_pm,
-            context_window:               nil,
-            max_output_tokens:            nil,
-            input_modalities:             inp_mods,
-            output_modalities:            out_mods,
-            image_input_per_million:      img_in_pm,
-            image_output_per_million:     img_out_pm,
-            audio_input_per_million:      audio_in_pm,
-            audio_output_per_million:     aud_out_pm,
-            web_search_per_request:       web_search_usd
-          )
-        end
-
-        # Per-token string → per-million float. Returns nil for zero/blank.
-        def to_pm(value)
-          return nil if value.nil? || value.to_s.strip.empty?
-          f = value.to_f
-          return nil if f <= 0
-          (f * 1_000_000).round(6)
-        end
-
-        def http_get(uri)
-          resp = Net::HTTP.start(uri.host, uri.port, use_ssl: true, read_timeout: 15) do |h|
-            h.get(uri.request_uri)
-          end
-          raise "OpenRouter API #{resp.code} for #{uri}" unless resp.is_a?(Net::HTTPSuccess)
-          resp
-        end
-
-        def project_root
-          if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
-            Rails.root.to_s
-          else
-            Dir.pwd
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_harness/pricing.rb

@@ -1,152 +0,0 @@
-require "json"
-
-module ActiveHarness
-  # Pricing namespace — shared types and a facade over pricing source modules.
-  #
-  # Sources (in priority order):
-  #   Pricing::OpenRouter  — live data from OpenRouter API  (image models, 24h cache)
-  #   Pricing::ModelsDev   — live data from models.dev API  (all providers, 24h cache)
-  #
-  # Public facade delegates to ModelsDev (used as the general fallback):
-  #   Pricing.find("gpt-4o")       → ModelPrice or nil
-  #   Pricing.all                  → Array<ModelPrice>
-  #   Pricing.providers.openai     → Array<ModelPrice>
-  #   Pricing.update               → refreshes ModelsDev cache
-  module Pricing
-    # Pricing rates for a single model.
-    # All *_per_million fields are in USD per 1M tokens.
-    # audio_input_per_million / audio_output_per_million may represent
-    # per-million audio tokens or per-unit (second/char) depending on provider.
-    ModelPrice = Struct.new(
-      :id,
-      :name,
-      :provider,
-      # Primary fields (used for cost calculation, backward-compatible)
-      :input_per_million,               # text tokens input
-      :output_per_million,              # primary output (text or image_output for imggen)
-      :cache_read_input_per_million,
-      :cache_write_input_per_million,
-      :context_window,
-      :max_output_tokens,
-      :input_modalities,
-      :output_modalities,
-      # Extended modality-specific pricing
-      :image_input_per_million,         # image tokens accepted as input (vision models)
-      :image_output_per_million,        # image generation output tokens (imggen models)
-      :audio_input_per_million,         # audio tokens accepted as input
-      :audio_output_per_million,        # audio output tokens (TTS models)
-      :web_search_per_request,          # per web-search call in USD
-      keyword_init: true
-    ) do
-      # Capability tags derived from modality data.
-      # Possible values: "vision", "pdf", "audio", "video", "imggen", "embed",
-      #                  "speech", "transcription", "rerank"
-      def categories
-        inp = Array(input_modalities)
-        out = Array(output_modalities)
-        cats = []
-        cats << "vision"        if inp.include?("image")
-        cats << "pdf"           if inp.include?("pdf")
-        cats << "audio"         if inp.include?("audio")
-        cats << "video"         if inp.include?("video") || out.include?("video")
-        cats << "imggen"        if out.include?("image")
-        cats << "speech"        if out.include?("speech")
-        cats << "transcription" if out.include?("transcription")
-        cats << "rerank"        if out.include?("rerank")
-        cats << "embed"         if out.include?("embeddings")
-        cats
-      end
-
-      def inspect
-        parts = ["id=#{id.inspect}", "provider=#{provider.inspect}"]
-        parts << "input=$#{input_per_million}/M"  if input_per_million
-        parts << "output=$#{output_per_million}/M" if output_per_million
-        parts << "ctx=#{context_window}"           if context_window
-        parts << "cats=#{categories.join(',')}"    if categories.any?
-        "#<ModelPrice #{parts.join(' ')}>"
-      end
-    end
-
-    # Proxy returned by Pricing.providers — exposes providers as methods and [].
-    class ProvidersProxy
-      def initialize(source = nil)
-        @source = source
-      end
-
-      def [](name)
-        source.for_provider(name.to_s)
-      end
-
-      def list
-        source.provider_names
-      end
-
-      def method_missing(name, *args, &block)
-        provider = name.to_s
-        if source.provider_names.include?(provider)
-          source.for_provider(provider)
-        else
-          super
-        end
-      end
-
-      def respond_to_missing?(name, include_private = false)
-        source.provider_names.include?(name.to_s) || super
-      end
-
-      private
-
-      def source
-        @source || ModelsDev
-      end
-    end
-
-    # ---------------------------------------------------------------------------
-    # Facade — delegates to ModelsDev (general fallback source)
-    # ---------------------------------------------------------------------------
-    class << self
-      # Eagerly fetch all pricing sources and load them into memory.
-      # Called at Rails startup. Network failures are silently ignored.
-      def preload!
-        ModelsDev.preload!
-        OpenRouter.preload!
-      end
-
-      def find(model_id)
-        ModelsDev.find(model_id)
-      end
-
-      def all
-        ModelsDev.all
-      end
-
-      def providers
-        ModelsDev.providers
-      end
-
-      def for_provider(name)
-        ModelsDev.for_provider(name)
-      end
-
-      def provider_names
-        ModelsDev.provider_names
-      end
-
-      def update
-        ModelsDev.update
-      end
-
-      def reload!
-        ModelsDev.reload!
-      end
-
-      def cache_file
-        ModelsDev.cache_file
-      end
-
-      def available_providers
-        ModelsDev.available_providers
-      end
-    end
-  end
-end