active_harness 0.2.33 → 0.2.35

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f53c6eb7b468113f17ded0ff474515db8dbb640dca9cda8e7c632f05eba3469b
-  data.tar.gz: 8ec97a06740588236a2ba6d38271aa62a92c5e91389678e73c94d4042da6d104
+  metadata.gz: f08d4dd9d2254cb4895919e690fd485cab05d2b89c53786383b0da353aeb5f82
+  data.tar.gz: 1aa9a3e3a7cd8a2e83179b88a9f3623f39b4fa59e7386d43094de2739f44d50a
 SHA512:
-  metadata.gz: 32ddb50bbe337cfd32613b878936db4d303e1e49b3648b18d1ff95b5a8cc27e657372b0bea5039d0fb785b169bb8492f468fc472e0ace153c1b7009090dce81c
-  data.tar.gz: cb45df7677c6f1d946d83722c9e5027f8a2803060116fe2cdb391771acd0bb3750dabfe2321dcb6a5e73841e6d7f7afb666ae10d88e506444d7a586a18257690
+  metadata.gz: 1aa38c722c75fbc04d6d389ebe6d260322eddd1a4d6c5bb9a43117b2b341447bf1883f90beacdcf5c2bc99adc6867a2dc7ee820f3dcd85d44538c5d148953a92
+  data.tar.gz: 146bf3d9516d70dcc45c2b092855b2b6b01543dd3b76e45de250b2b91fecce700cbabf7f492ebbf2e7417dfca22a48c21b2247a361b83eb28a81b001a3ce5999

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,218 @@
+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

@@ -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