active_harness 0.2.33 → 0.2.34

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f53c6eb7b468113f17ded0ff474515db8dbb640dca9cda8e7c632f05eba3469b
-  data.tar.gz: 8ec97a06740588236a2ba6d38271aa62a92c5e91389678e73c94d4042da6d104
+  metadata.gz: 39b817ef529f0158a20634ba42a61ae0078404238038b22d63c2c8cc50a1ff3a
+  data.tar.gz: bcf8d21cb68449e3962f2bb9b515c39237c7774a6ca300a803775ae09c275567
 SHA512:
-  metadata.gz: 32ddb50bbe337cfd32613b878936db4d303e1e49b3648b18d1ff95b5a8cc27e657372b0bea5039d0fb785b169bb8492f468fc472e0ace153c1b7009090dce81c
-  data.tar.gz: cb45df7677c6f1d946d83722c9e5027f8a2803060116fe2cdb391771acd0bb3750dabfe2321dcb6a5e73841e6d7f7afb666ae10d88e506444d7a586a18257690
+  metadata.gz: e09428cecc83c7fe3caed3c45c4caf000ee07a5b783acbfe3b591de02615af98498e7b490f0b6e5d7a34b5dcbdf12a4afd252a197c4fa71e6a1eabfd466d4b92
+  data.tar.gz: e80805c251e3a48ce0ab032a9c8904dae3401c6d02bedb9d1372df32ada7b9609880096c2fb39c62d575aecdace7266d068f6e0ed165ece989038b29e1b74885

data/lib/active_harness/agent/image.rb

@@ -0,0 +1,56 @@
+module ActiveHarness
+  class Agent
+    class << self
+      # Mark this agent as an image generation agent.
+      #
+      #   class ImageAgent < ActiveHarness::Agent
+      #     image true
+      #     size  "1024x1024"
+      #
+      #     model do
+      #       use      provider: :openrouter, model: "openai/gpt-5-image-mini"
+      #       fallback provider: :openai,     model: "gpt-image-1"
+      #     end
+      #   end
+      #
+      # result.output   — base64 string or data-URI (provider-dependent)
+      # result.processed — same as output (format :text default)
+      def image(value = true)
+        agent_config[:image] = value
+      end
+
+      # Default image size for all models in this agent's chain.
+      # Can be overridden per-model via:  use provider: :openai, model: "...", size: "1024x1792"
+      def size(default_size)
+        agent_config[:image_size] = default_size
+      end
+    end
+
+    alias_method :_model_list_base, :model_list
+
+    def model_list
+      list = _model_list_base
+      validate_image_models!(list) if @config[:image]
+      list
+    end
+
+    private
+
+    # Models absent from the Pricing registry are silently skipped — unknown
+    # models are assumed valid to avoid false negatives on new/private models.
+    def validate_image_models!(list)
+      list.each do |entry|
+        info = Pricing.find(entry[:model].to_s)
+        next unless info
+
+        unless info.categories.include?("imggen")
+          raise ArgumentError,
+            "#{self.class.name}: model #{entry[:model].inspect} (provider: #{entry[:provider]}) " \
+            "does not support image generation " \
+            "(output_modalities: #{info.output_modalities.inspect}). " \
+            "Use a model that has 'image' in output_modalities."
+        end
+      end
+    end
+  end
+end

data/lib/active_harness/agent/models.rb

@@ -134,12 +134,14 @@ module ActiveHarness
       @models = []
     end
 
-    def use(provider:, model:, temperature: nil, name: nil, retry_attempts: nil, retry_delay: nil)
+    def use(provider:, model:, temperature: nil, name: nil, size: nil, quality: nil, retry_attempts: nil, retry_delay: nil)
       @models << {
         provider:       provider,
         model:          model,
         temperature:    temperature,
         name:           name,
+        size:           size,
+        quality:        quality,
         retry_attempts: retry_attempts,
         retry_delay:    retry_delay
       }.compact

data/lib/active_harness/agent/providers.rb

@@ -38,10 +38,16 @@ module ActiveHarness
       custom:      -> { Providers::Custom.new }
     }.freeze
 
+    IMAGE_PROVIDERS = {
+      openai:      -> { Providers::Images::OpenAI.new },
+      openrouter:  -> { Providers::Images::OpenRouter.new }
+    }.freeze
+
     private
 
     def attempt_model(entry, system_prompt)
       return attempt_via_custom_llm(entry, system_prompt) if @config[:custom_llm_backend]
+      return attempt_image_model(entry)                   if @config[:image]
 
       provider = resolve_provider(entry[:provider])
       messages = build_messages(system_prompt, @input)
@@ -52,6 +58,17 @@ module ActiveHarness
       provider.call(**opts)
     end
 
+    def attempt_image_model(entry)
+      factory = IMAGE_PROVIDERS[entry[:provider].to_sym]
+      raise ArgumentError, "Provider #{entry[:provider].inspect} does not support image generation. " \
+                           "Supported image providers: #{IMAGE_PROVIDERS.keys.join(', ')}" unless factory
+
+      size = entry[:size] || @config[:image_size] || "1024x1024"
+      opts = { model: entry[:model], prompt: @input.to_s, size: size }
+      opts[:quality] = entry[:quality] if entry[:quality]
+      factory.call.call(**opts)
+    end
+
     def resolve_provider(name)
       factory = PROVIDERS[name.to_sym]
       raise ArgumentError, "Unknown provider: #{name.inspect}. Supported: #{PROVIDERS.keys.join(', ')}" unless factory

data/lib/active_harness/agent.rb

@@ -188,15 +188,23 @@ module ActiveHarness
         total:  raw_usage[:total_tokens]
       )
 
-      UsageInfo.new(
-        tokens: tokens,
-        cost:   calculate_cost(model_cost, tokens)
-      )
+      cost = if raw_usage.key?(:provider_cost)
+        CostBreakdown.new(total: raw_usage[:provider_cost].round(8))
+      else
+        calculate_cost(model_cost, tokens)
+      end
+
+      UsageInfo.new(tokens: tokens, cost: cost)
     end
 
     def lookup_model_cost(entry)
       return nil unless entry
-      Pricing.find(entry[:model].to_s)
+
+      if entry[:provider].to_sym == :openrouter
+        Pricing::OpenRouter.find(entry[:model].to_s) || Pricing.find(entry[:model].to_s)
+      else
+        Pricing.find(entry[:model].to_s)
+      end
     rescue StandardError
       nil
     end
@@ -215,4 +223,5 @@ require_relative "agent/providers"
 require_relative "agent/output_parser"
 require_relative "agent/custom_llm_backend"
 require_relative "agent/cost"
+require_relative "agent/image"
 

data/lib/active_harness/pricing/models_dev.rb

@@ -0,0 +1,194 @@
+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"
+      CACHE_TTL         = 86_400
+
+      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
+
+        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))
+
+          reload!
+          models.size
+        end
+
+        def reload!
+          @registry       = nil
+          @provider_names = nil
+          nil
+        end
+
+        def cache_file
+          File.join(project_root, "tmp", "active_harness", "pricing_models_dev.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 cache_file_fresh?
+          update
+        rescue StandardError
+          # Network unavailable — fall back to bundled/stale cache silently
+        end
+
+        def cache_file_fresh?
+          File.exist?(cache_file) && (Time.now - File.mtime(cache_file)) < CACHE_TTL
+        end
+
+        def registry
+          @registry ||= load_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,176 @@
+require "json"
+require "net/http"
+require "uri"
+require "fileutils"
+
+module ActiveHarness
+  module Pricing
+    # Fetches image-model pricing directly from the OpenRouter API.
+    #
+    # models.dev only has generic prompt/completion rates for OpenRouter models.
+    # OpenRouter's own /endpoints API exposes a separate `image_output` rate
+    # that reflects the real cost of image generation tokens.
+    #
+    # Data flow:
+    #   1. GET /api/v1/models?output_modalities=image  → list of image models
+    #   2. GET /api/v1/models/{id}/endpoints           → per-model, picks first
+    #      active endpoint to get image_output rate
+    #   3. Result cached to tmp/active_harness/pricing_openrouter.json for 24h
+    #
+    # Usage:
+    #   Pricing::OpenRouter.find("openai/gpt-5-image-mini")  # → ModelPrice or nil
+    #   Pricing::OpenRouter.update                           # force refresh
+    module OpenRouter
+      API_BASE  = "https://openrouter.ai/api/v1/models"
+      CACHE_TTL = 86_400
+
+      class << self
+        # Returns a ModelPrice for the given OpenRouter model id, or nil.
+        # Automatically refreshes the cache if missing or stale.
+        def find(model_id)
+          ensure_fresh_registry
+          raw = registry.find { |m| m[:id] == model_id.to_s }
+          raw ? build_price(raw) : nil
+        end
+
+        # Fetches fresh data from OpenRouter and writes the cache.
+        # Returns the number of models saved.
+        def update
+          image_models = fetch_image_models
+          enriched = image_models.map { |m| enrich_with_endpoint(m) }
+
+          FileUtils.mkdir_p(File.dirname(cache_file))
+          File.write(cache_file, JSON.generate(enriched))
+          reload!
+          enriched.size
+        end
+
+        def reload!
+          @registry = nil
+        end
+
+        def cache_file
+          File.join(project_root, "tmp", "active_harness", "pricing_openrouter.json")
+        end
+
+        private
+
+        def ensure_fresh_registry
+          return if cache_fresh?
+          update
+        rescue StandardError
+          # network unavailable — fall back to stale cache silently
+        end
+
+        def cache_fresh?
+          File.exist?(cache_file) && (Time.now - File.mtime(cache_file)) < CACHE_TTL
+        end
+
+        def registry
+          @registry ||= begin
+            return [] unless File.exist?(cache_file)
+            JSON.parse(File.read(cache_file), symbolize_names: true)
+          rescue JSON::ParserError
+            []
+          end
+        end
+
+        # Fetch all models with image output from OpenRouter.
+        def fetch_image_models
+          uri = URI("#{API_BASE}?output_modalities=image")
+          response = http_get(uri)
+          data = JSON.parse(response.body, symbolize_names: true)
+          data[:data] || []
+        end
+
+        # Fetch /endpoints for the model and merge image_output pricing.
+        def enrich_with_endpoint(model)
+          model_id = model[:id]
+          base_pricing = model[:pricing] || {}
+
+          endpoint_pricing = fetch_endpoint_pricing(model_id)
+
+          {
+            id:               model_id,
+            name:             model[:name],
+            input_modalities:  model.dig(:architecture, :input_modalities)  || [],
+            output_modalities: model.dig(:architecture, :output_modalities) || [],
+            prompt:            base_pricing[:prompt].to_s,
+            completion:        base_pricing[:completion].to_s,
+            image_output:      endpoint_pricing&.dig(:image_output).to_s,
+            image:             endpoint_pricing&.dig(:image).to_s,
+            cache_read:        (endpoint_pricing&.dig(:input_cache_read) || base_pricing[:input_cache_read]).to_s
+          }
+        end
+
+        # Returns the pricing hash from the first active endpoint, or nil.
+        def fetch_endpoint_pricing(model_id)
+          uri = URI("#{API_BASE}/#{model_id}/endpoints")
+          response = http_get(uri)
+          data = JSON.parse(response.body, symbolize_names: true)
+          endpoints = data.dig(:data, :endpoints) || []
+
+          # Prefer the first endpoint with status == 0 (online), else first available.
+          ep = endpoints.find { |e| e[:status] == 0 } || endpoints.first
+          ep&.dig(:pricing)
+        rescue StandardError
+          nil
+        end
+
+        # Build a ModelPrice compatible with the rest of the Pricing system.
+        # For image-output models, uses image_output rate for output_per_million.
+        def build_price(raw)
+          is_image_output = Array(raw[:output_modalities]).include?("image")
+
+          input_pm      = to_per_million(raw[:prompt])
+          completion_pm = to_per_million(raw[:completion])
+          image_out_pm  = to_per_million(raw[:image_output])
+          cache_pm      = to_per_million(raw[:cache_read])
+
+          output_pm = (is_image_output && image_out_pm) ? image_out_pm : completion_pm
+
+          return nil unless input_pm || output_pm
+
+          Pricing::ModelPrice.new(
+            id:                           raw[:id],
+            name:                         raw[:name],
+            provider:                     "openrouter",
+            input_per_million:            input_pm,
+            output_per_million:           output_pm,
+            cache_read_input_per_million: cache_pm,
+            cache_write_input_per_million: nil,
+            context_window:               nil,
+            max_output_tokens:            nil,
+            input_modalities:             Array(raw[:input_modalities]),
+            output_modalities:            Array(raw[:output_modalities])
+          )
+        end
+
+        # OpenRouter pricing fields are per-token strings (e.g. "0.000008").
+        # Convert to per-million float. Returns nil for zero/blank values.
+        def to_per_million(value)
+          return nil if value.nil? || value.to_s.empty?
+          f = value.to_f
+          return nil if f <= 0
+          (f * 1_000_000).round(6)
+        end
+
+        def http_get(uri)
+          response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https", read_timeout: 10) do |http|
+            http.get(uri.request_uri)
+          end
+          raise "OpenRouter API returned HTTP #{response.code} for #{uri}" unless response.is_a?(Net::HTTPSuccess)
+          response
+        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