active_harness_pricing 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ac53afc65a92dfd05822664fcb797fb9d785eba4be2148295e5ee898f1e2236b
+  data.tar.gz: fa65d9618561a7f6d346713b7ec2000688e504cf6aa120db7b9282f54e5c79a4
+SHA512:
+  metadata.gz: b1fd5891bee21ca2c575b7046b0dee73ce90791d58fb231ebc68633f96b2d7efac48bfb1ae6db1b0c5668e699cff36cf31cba592de4bf7a6ddd402a5baefd711
+  data.tar.gz: 963a2238509aa0c4acf2017ed871e23a02aa5187c62275b787732e9141977b8606c11430f7202da87d9c0725b51ee6e4e4e66df8ba932c959bb269aaa19c6cc1

data/lib/active_harness/pricing/models_dev.rb

@@ -0,0 +1,220 @@
+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
+
+        # Returns all providers known to this gem.
+        # Can be overridden by assigning an explicit list:
+        #   ActiveHarness::Pricing::ModelsDev.available_providers = %w[openai anthropic]
+        def available_providers
+          @available_providers ||= MODELS_DEV_PROVIDER_MAP.values.uniq
+        end
+
+        def available_providers=(list)
+          @available_providers = list
+        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

@@ -0,0 +1,323 @@
+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

@@ -0,0 +1,152 @@
+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

data/lib/active_harness_pricing.rb

@@ -0,0 +1,7 @@
+require_relative "active_harness/pricing"
+require_relative "active_harness/pricing/models_dev"
+require_relative "active_harness/pricing/openrouter"
+
+module ActiveHarnessPricing
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: active_harness_pricing
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- the-teacher
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-06-14 00:00:00.000000000 Z
+dependencies: []
+description: 
+email:
+- the-teacher@github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/active_harness/pricing.rb
+- lib/active_harness/pricing/models_dev.rb
+- lib/active_harness/pricing/openrouter.rb
+- lib/active_harness_pricing.rb
+homepage: https://github.com/the-teacher/active_harness
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: LLM model pricing data — models.dev and OpenRouter sources
+test_files: []