ruby_llm-contract 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4620ae344425d6b9473b5265821d9bc16e25c7ade812f2c0d89a7926859a2e2e
-  data.tar.gz: 68565f25b5aa97b9804c9e91cec01cf0253602686e709f94ed26a07fe2bf3ce9
+  metadata.gz: 390af91f8200f1098440872d22515fa6232888d13d21a149c0b11f0bf3c15d48
+  data.tar.gz: d39d8a0c2e8914d08e4d996e6a3eb4d2c53613304cabcc6e077af2d9963ad4f5
 SHA512:
-  metadata.gz: 3c1b4e7ef0f06065bfecd68742c07e40c50e7f08c53760a24097ed5a7fe9eaa84dbf9796fab40dd1096791c623c14bdc48eb3a44e39ebd5858bbc21bd888c24c
-  data.tar.gz: b2f3aaa92a43c8e638bcbe30d46cf0629cca8f201416cf848fc2d9b93ed7d9a393e92973ec2e3dc69ce6951b0d4c436955d8a5fd976161f93c1fd587be437877
+  metadata.gz: 81e03a20720536700acfe5bc840720a84675ca738e248fbdb490dac1dc63479c93924923d16cb28433329b53d24b796a42332736d29ec6f4d42a41240dfd4367
+  data.tar.gz: a433acb982c831c7ee1e2db5675135c4a42762d75c78e53708673b8ca50f5f165fe2cba9a088828b95738f24f29afb01e2033f694e92c69182662a6307492aa4

data/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## 1.1.1 (2026-10-10)
+
+### Fixed
+
+- **A failed rake eval gate printed "Eval suite FAILED: Eval suite FAILED".** The
+  message now reads "Eval suite FAILED: one or more evals did not pass".
+
+### Changed (internal, no API change)
+
+- Values that two or more places must agree on now have one owner, so one side can no
+  longer drift alone: the `:refuse`/`:warn` modes and their default for every
+  `on_unknown_*` option (`UnknownPolicy`), the Rails contract and eval dirs that the
+  Railtie ignores and `load_evals!` loads, the reload flag, the `:skipped` step status
+  (`CaseResult::SKIPPED_STATUS`), baseline and history file extensions, the context keys
+  forwarded to the adapter, the generic "passed"/"not passed" details the report hides,
+  and the optimize task's `MIN_SCORE` default, which now reads `Eval::DEFAULT_MIN_SCORE`.
+  The unknown-context-key warning lists the known keys in a different order, and in a
+  Rails app `load_evals!` now loads `app/contracts/eval` before `app/steps/eval` (the order
+  the Railtie and eager loading already used); this matters only if both dirs define an
+  eval of the same name on the same class, where the later file wins.
+
+### Tests
+
+- A real attachment through the RubyLLM 2.x adapter with HTTP intercepted (webmock):
+  pins the `input_image` part on the wire and the usage read back.
+- A minimal Rails app booted in a child process: pins that Zeitwerk ignores the
+  `eval/` dirs, that evals register after boot, and that the rake tasks appear.
+- `rubocop` is pinned to `~> 1.92.0`: CI resolves without a lockfile, so a floating
+  version let new cops land on CI before they ran locally.
+
 ## 1.1.0 (2026-10-10)
 
 ### Changed - may turn a green CI red

data/lib/ruby_llm/contract/concerns/eval_host.rb

@@ -16,13 +16,13 @@ module RubyLLM
           @file_sourced_evals ||= Set.new
           key = name.to_s
 
-          if @eval_definitions.key?(key) && !Thread.current[:ruby_llm_contract_reloading]
+          if @eval_definitions.key?(key) && !Contract.reloading?
             warn "[ruby_llm-contract] Redefining eval '#{key}' on #{self}. " \
                  "This replaces the previous definition."
           end
 
           @eval_definitions[key] = Eval::EvalDefinition.new(key, step_class: self, &)
-          @file_sourced_evals.add(key) if Thread.current[:ruby_llm_contract_reloading]
+          @file_sourced_evals.add(key) if Contract.reloading?
           Contract.register_eval_host(self)
           register_subclasses(self)
         end

data/lib/ruby_llm/contract/eval/case_executor.rb

@@ -39,7 +39,7 @@ module RubyLLM
             input: test_case.input,
             output: nil,
             expected: test_case.expected,
-            step_status: :skipped,
+            step_status: CaseResult::SKIPPED_STATUS,
             score: 0.0,
             passed: false,
             label: "SKIP",

data/lib/ruby_llm/contract/eval/case_result.rb

@@ -7,6 +7,9 @@ module RubyLLM
         # BaselineDiff#compute_score keys off this prefix to keep skipped cases
         # out of the score denominator. Both ends must read it from here.
         SKIPPED_DETAILS_PREFIX = "skipped:"
+        # Not run (no adapter). Readers compare step_status, so any result object
+        # exposing it works; kept out of score, pass rate and cost-per-call.
+        SKIPPED_STATUS = :skipped
 
         def self.skipped_details(reason)
           "#{SKIPPED_DETAILS_PREFIX} #{reason}"

data/lib/ruby_llm/contract/eval/evaluator/proc_evaluator.rb

@@ -6,6 +6,10 @@ module RubyLLM
       module Evaluator
         # Adapts custom Ruby callables to the EvaluationResult contract.
         class ProcEvaluator
+          # Report hides these under a failure: they repeat the PASS/FAIL label.
+          PASSED_DETAILS = "passed"
+          FAILED_DETAILS = "not passed"
+
           def initialize(callable)
             @callable = callable
           end
@@ -36,9 +40,9 @@ module RubyLLM
           def build_evaluation_result(result)
             case result
             when true
-              EvaluationResult.new(score: 1.0, passed: true, details: "passed")
+              EvaluationResult.new(score: 1.0, passed: true, details: PASSED_DETAILS)
             when false
-              EvaluationResult.new(score: 0.0, passed: false, details: "not passed")
+              EvaluationResult.new(score: 0.0, passed: false, details: FAILED_DETAILS)
             when Numeric
               EvaluationResult.new(score: result, passed: result >= 0.5, details: "custom score: #{result}")
             else

data/lib/ruby_llm/contract/eval/prompt_diff_serializer.rb

@@ -5,7 +5,7 @@ module RubyLLM
     module Eval
       class PromptDiffSerializer
         def call(report)
-          report.results.reject { |result| result.step_status == :skipped }.map do |result|
+          report.results.reject { |result| result.step_status == CaseResult::SKIPPED_STATUS }.map do |result|
             {
               name: result.name,
               input: result.input,

data/lib/ruby_llm/contract/eval/recommender.rb

@@ -40,7 +40,7 @@ module RubyLLM
             report = @comparison.reports[label]
             next nil unless report
 
-            evaluated_count = report.results.count { |r| r.step_status != :skipped }
+            evaluated_count = report.results.count { |r| r.step_status != CaseResult::SKIPPED_STATUS }
             cases_count = [evaluated_count, 1].max
             cost_per_call = report.total_cost.to_f / cases_count
 
@@ -116,7 +116,7 @@ module RubyLLM
           current_report = @comparison.reports[current_label]
           return {} unless current_report
 
-          current_evaluated = current_report.results.count { |r| r.step_status != :skipped }
+          current_evaluated = current_report.results.count { |r| r.step_status != CaseResult::SKIPPED_STATUS }
           current_cases = [current_evaluated, 1].max
           current_cost = current_report.total_cost.to_f / current_cases
           diff = current_cost - best[:cost_per_call]

data/lib/ruby_llm/contract/eval/report.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "forwardable"
+require_relative "evaluator/proc_evaluator"
 
 module RubyLLM
   module Contract
@@ -10,9 +11,11 @@ module RubyLLM
 
         attr_reader :dataset_name, :results, :step_name
 
-        GENERIC_DETAILS = ["passed", "not passed"].freeze
+        GENERIC_DETAILS = [Evaluator::ProcEvaluator::PASSED_DETAILS, Evaluator::ProcEvaluator::FAILED_DETAILS].freeze
         HISTORY_DIR = ".eval_history"
+        HISTORY_EXT = "jsonl"
         BASELINE_DIR = ".eval_baselines"
+        BASELINE_EXT = "json"
 
         def_delegators :@stats, :score, :passed, :failed, :skipped, :failures, :pass_rate, :pass_rate_ratio,
                        :total_cost, :unknown_cost_results, :avg_latency_ms, :passed?,

data/lib/ruby_llm/contract/eval/report_stats.rb

@@ -23,7 +23,7 @@ module RubyLLM
         end
 
         def skipped
-          @results.count { |result| result.step_status == :skipped }
+          @results.count { |result| result.step_status == CaseResult::SKIPPED_STATUS }
         end
 
         def failures
@@ -63,7 +63,7 @@ module RubyLLM
         end
 
         def evaluated_results
-          @evaluated_results ||= @results.reject { |result| result.step_status == :skipped }
+          @evaluated_results ||= @results.reject { |result| result.step_status == CaseResult::SKIPPED_STATUS }
         end
 
         def evaluated_results_count

data/lib/ruby_llm/contract/eval/report_storage.rb

@@ -13,7 +13,7 @@ module RubyLLM
         end
 
         def save_history!(path: nil, model: nil, reasoning_effort: nil)
-          file = path || storage_path(Report::HISTORY_DIR, "jsonl", model: model, reasoning_effort: reasoning_effort)
+          file = path || storage_path(Report::HISTORY_DIR, Report::HISTORY_EXT, model: model, reasoning_effort: reasoning_effort)
           entry = history_entry
           entry[:model] = model if model
           entry[:reasoning_effort] = reasoning_effort if reasoning_effort
@@ -22,19 +22,19 @@ module RubyLLM
         end
 
         def eval_history(path: nil, model: nil, reasoning_effort: nil)
-          EvalHistory.load(path || storage_path(Report::HISTORY_DIR, "jsonl", model: model,
-                                                                              reasoning_effort: reasoning_effort))
+          EvalHistory.load(path || storage_path(Report::HISTORY_DIR, Report::HISTORY_EXT,
+                                                model: model, reasoning_effort: reasoning_effort))
         end
 
         def save_baseline!(path: nil, model: nil, reasoning_effort: nil)
-          file = path || storage_path(Report::BASELINE_DIR, "json", model: model, reasoning_effort: reasoning_effort)
+          file = path || storage_path(Report::BASELINE_DIR, Report::BASELINE_EXT, model: model, reasoning_effort: reasoning_effort)
           FileUtils.mkdir_p(File.dirname(file))
           File.write(file, JSON.pretty_generate(serialize_for_baseline))
           file
         end
 
         def compare_with_baseline(path: nil, model: nil, reasoning_effort: nil)
-          file = path || storage_path(Report::BASELINE_DIR, "json", model: model, reasoning_effort: reasoning_effort)
+          file = path || storage_path(Report::BASELINE_DIR, Report::BASELINE_EXT, model: model, reasoning_effort: reasoning_effort)
           raise ArgumentError, "No baseline found at #{file}" unless File.exist?(file)
 
           baseline_data = JSON.parse(File.read(file), symbolize_names: true)
@@ -47,7 +47,7 @@ module RubyLLM
         end
 
         def baseline_exists?(path: nil, model: nil, reasoning_effort: nil)
-          File.exist?(path || storage_path(Report::BASELINE_DIR, "json", model: model, reasoning_effort: reasoning_effort))
+          File.exist?(path || storage_path(Report::BASELINE_DIR, Report::BASELINE_EXT, model: model, reasoning_effort: reasoning_effort))
         end
 
         private

data/lib/ruby_llm/contract/eval/unknown_cost_gate.rb

@@ -8,14 +8,6 @@ module RubyLLM
       # gate that only compares totals passes whatever those cases really cost.
       # Shared by the rake task, the pass_eval matcher and assert_eval_passes.
       module UnknownCostGate
-        MODES = %i[refuse warn].freeze
-
-        def self.validate!(mode)
-          return mode if MODES.include?(mode)
-
-          raise ArgumentError, "on_unknown_pricing must be :refuse or :warn, got #{mode.inspect}"
-        end
-
         # Returns the failure message under :refuse, nil when the gate holds.
         def self.check(reports, mode:)
           names = reports.flat_map(&:unknown_cost_results).map(&:name).uniq

data/lib/ruby_llm/contract/minitest.rb

@@ -31,8 +31,8 @@ module RubyLLM
       end
 
       def assert_eval_passes(step, eval_name, minimum_score: nil, maximum_cost: nil, context: {}, msg: nil,
-                             on_unknown_pricing: :refuse)
-        Eval::UnknownCostGate.validate!(on_unknown_pricing)
+                             on_unknown_pricing: UnknownPolicy::DEFAULT)
+        UnknownPolicy.validate!("on_unknown_pricing", on_unknown_pricing)
         report = step.run_eval(eval_name, context: context)
 
         if minimum_score

data/lib/ruby_llm/contract/railtie.rb

@@ -6,7 +6,7 @@ module RubyLLM
       # Ignore eval/ subdirs BEFORE Zeitwerk setup — eval files don't define
       # constants, they call define_eval on existing Step classes.
       initializer "ruby_llm_contract.ignore_eval_dirs", before: :set_autoload_paths do |app|
-        %w[app/contracts/eval app/steps/eval].each do |path|
+        RubyLLM::Contract::RAILS_EVAL_DIRS.each do |path|
           full = app.root.join(path)
           next unless full.exist?
 

data/lib/ruby_llm/contract/rake_task/suite_gate.rb

@@ -18,7 +18,7 @@ module RubyLLM
         end
 
         def self.evaluate(host_reports:, minimum_score:, maximum_cost:, fail_on_regression:,
-                          on_unknown_pricing: :refuse)
+                          on_unknown_pricing: UnknownPolicy::DEFAULT)
           new(host_reports: host_reports,
               minimum_score: minimum_score,
               maximum_cost: maximum_cost,
@@ -29,12 +29,12 @@ module RubyLLM
         attr_reader :verdict
 
         def initialize(host_reports:, minimum_score:, maximum_cost:, fail_on_regression:,
-                       on_unknown_pricing: :refuse)
+                       on_unknown_pricing: UnknownPolicy::DEFAULT)
           @host_reports = host_reports
           @minimum_score = minimum_score
           @maximum_cost = maximum_cost
           @fail_on_regression = fail_on_regression
-          @on_unknown_pricing = Eval::UnknownCostGate.validate!(on_unknown_pricing)
+          @on_unknown_pricing = UnknownPolicy.validate!("on_unknown_pricing", on_unknown_pricing)
           @verdict = build_verdict
         end
 
@@ -56,7 +56,7 @@ module RubyLLM
           passed_reports, all_passed = score_each_report
           Verdict.new(
             passed: all_passed,
-            abort_reason: all_passed ? nil : "Eval suite FAILED",
+            abort_reason: all_passed ? nil : "one or more evals did not pass",
             passed_reports: passed_reports,
             suite_cost: suite_cost
           )

data/lib/ruby_llm/contract/rake_task.rb

@@ -2,7 +2,7 @@
 
 require "rake"
 require "rake/tasklib"
-require_relative "eval/unknown_cost_gate"
+require_relative "unknown_policy"
 require_relative "rake_task/suite_gate"
 
 module RubyLLM
@@ -21,12 +21,12 @@ module RubyLLM
         @maximum_cost = nil  # nil = no cost limit; float = budget cap (suite-level)
         @eval_dirs = []      # directories to load eval files from (non-Rails)
         # With maximum_cost: :refuse fails on cases the budget cannot price; :warn gates priced cases only
-        @on_unknown_pricing = :refuse
+        @on_unknown_pricing = UnknownPolicy::DEFAULT
         @save_baseline = false
         @fail_on_regression = false
         @track_history = false
         block&.call(self)
-        Eval::UnknownCostGate.validate!(@on_unknown_pricing)
+        UnknownPolicy.validate!("on_unknown_pricing", @on_unknown_pricing)
         define_task
       end
 
@@ -134,7 +134,7 @@ module RubyLLM
           abort("STEP is required, e.g. STEP=MatchProblemsToPages") if step_name.empty?
           raw_candidates = ENV["CANDIDATES"].to_s.strip
           abort("CANDIDATES is required, e.g. CANDIDATES=gpt-5-nano,gpt-5-mini@low,gpt-5-mini") if raw_candidates.empty?
-          min_score = ENV.fetch("MIN_SCORE", "0.95").to_f
+          min_score = ENV.fetch("MIN_SCORE") { Eval::DEFAULT_MIN_SCORE }.to_f
           runs = parse_runs(ENV.fetch("RUNS", "1"))
 
           host = RubyLLM::Contract.eval_hosts.find { |h| h.name == step_name }

data/lib/ruby_llm/contract/rspec/pass_eval.rb

@@ -65,7 +65,7 @@ RSpec::Matchers.define :pass_eval do |eval_name|
   end
 
   chain :on_unknown_pricing do |mode|
-    @on_unknown_pricing = RubyLLM::Contract::Eval::UnknownCostGate.validate!(mode)
+    @on_unknown_pricing = RubyLLM::Contract::UnknownPolicy.validate!("on_unknown_pricing", mode)
   end
 
   chain :without_regressions do
@@ -82,7 +82,7 @@ RSpec::Matchers.define :pass_eval do |eval_name|
     @context ||= {}
     @minimum_score ||= nil
     @maximum_cost ||= nil
-    @on_unknown_pricing ||= :refuse
+    @on_unknown_pricing ||= RubyLLM::Contract::UnknownPolicy::DEFAULT
     @unknown_cost_failure = nil
     @unknown_cost_only = false
     @check_regressions ||= false

data/lib/ruby_llm/contract/step/base.rb

@@ -90,8 +90,10 @@ module RubyLLM
             ).call
           end
 
-          KNOWN_CONTEXT_KEYS = %i[adapter model temperature max_tokens provider assume_model_exists
-                                  reasoning_effort retry_policy_override attachment].freeze
+          # Forwarded to the adapter as-is. A key known but not forwarded would be
+          # silently dropped, so the known list is built from this one.
+          ADAPTER_CONTEXT_KEYS = %i[provider assume_model_exists max_tokens reasoning_effort attachment].freeze
+          KNOWN_CONTEXT_KEYS = (%i[adapter model temperature retry_policy_override] + ADAPTER_CONTEXT_KEYS).freeze
 
           include Concerns::ContextHelpers
 
@@ -133,7 +135,7 @@ module RubyLLM
             estimate = attachment_token_estimate if respond_to?(:attachment_token_estimate)
             return [estimate, false] unless estimate.nil?
 
-            mode = respond_to?(:on_unknown_attachment_size) ? on_unknown_attachment_size : :refuse
+            mode = respond_to?(:on_unknown_attachment_size) ? on_unknown_attachment_size : UnknownPolicy::DEFAULT
             if mode == :warn
               warn "[ruby_llm-contract] attachment present but attachment_token_estimate not " \
                    "declared on #{name || self} — estimate_cost proceeds without attachment cost"
@@ -193,7 +195,7 @@ module RubyLLM
 
           def runtime_settings(context)
             policy = context.key?(:retry_policy_override) ? context[:retry_policy_override] : retry_policy
-            extra = context.slice(:provider, :assume_model_exists, :max_tokens, :reasoning_effort, :attachment)
+            extra = context.slice(*ADAPTER_CONTEXT_KEYS)
 
             # Always pass the class-level `thinking` config to the adapter when
             # set, so fields like `budget` survive a per-call `reasoning_effort`

data/lib/ruby_llm/contract/step/dsl.rb

@@ -151,12 +151,10 @@ module RubyLLM
           if amount
             validate_positive!("max_cost", amount)
 
-            if on_unknown_pricing && !%i[refuse warn].include?(on_unknown_pricing)
-              raise ArgumentError, "on_unknown_pricing must be :refuse or :warn, got #{on_unknown_pricing.inspect}"
-            end
+            UnknownPolicy.validate!("on_unknown_pricing", on_unknown_pricing) if on_unknown_pricing
 
             @max_cost = amount
-            @on_unknown_pricing = on_unknown_pricing || :refuse
+            @on_unknown_pricing = on_unknown_pricing || UnknownPolicy::DEFAULT
             return @max_cost
           end
 
@@ -164,7 +162,7 @@ module RubyLLM
         end
 
         def on_unknown_pricing
-          inherited_value(:on_unknown_pricing) || :refuse
+          inherited_value(:on_unknown_pricing) || UnknownPolicy::DEFAULT
         end
 
         def attachment_token_estimate(n = nil)
@@ -182,16 +180,9 @@ module RubyLLM
         end
 
         def on_unknown_attachment_size(mode = nil)
-          if mode
-            unless %i[refuse warn].include?(mode)
-              raise ArgumentError,
-                    "on_unknown_attachment_size must be :refuse or :warn, got #{mode.inspect}"
-            end
-
-            return @on_unknown_attachment_size = mode
-          end
+          return @on_unknown_attachment_size = UnknownPolicy.validate!("on_unknown_attachment_size", mode) if mode
 
-          inherited_value(:on_unknown_attachment_size) || :refuse
+          inherited_value(:on_unknown_attachment_size) || UnknownPolicy::DEFAULT
         end
 
         def model(name = nil)

data/lib/ruby_llm/contract/step/runner_config.rb

@@ -28,8 +28,8 @@ module RubyLLM
         def self.build(input_type:, output_type:, prompt_block:, contract_definition:,
                        adapter:, model:,
                        output_schema: nil, max_output: nil,
-                       max_input: nil, max_cost: nil, on_unknown_pricing: :refuse,
-                       attachment_token_estimate: nil, on_unknown_attachment_size: :refuse,
+                       max_input: nil, max_cost: nil, on_unknown_pricing: UnknownPolicy::DEFAULT,
+                       attachment_token_estimate: nil, on_unknown_attachment_size: UnknownPolicy::DEFAULT,
                        temperature: nil, extra_options: {}, observers: [])
           new(
             input_type: input_type, output_type: output_type,

data/lib/ruby_llm/contract/unknown_policy.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Contract
+    # What a limit does when the number it needs is unknown: model pricing for
+    # max_cost/maximum_cost, attachment size for max_input. One vocabulary for
+    # every such option, step-level and eval-level, so a new mode or a changed
+    # default reaches all of them. Standalone: the rake task loads it before the
+    # rest of the gem to validate its settings at definition time.
+    module UnknownPolicy
+      MODES = %i[refuse warn].freeze
+      DEFAULT = :refuse
+
+      def self.validate!(option, mode)
+        return mode if MODES.include?(mode)
+
+        raise ArgumentError, "#{option} must be #{MODES.map(&:inspect).join(" or ")}, got #{mode.inspect}"
+      end
+    end
+  end
+end

data/lib/ruby_llm/contract/version.rb

@@ -2,6 +2,6 @@
 
 module RubyLLM
   module Contract
-    VERSION = "1.1.0"
+    VERSION = "1.1.1"
   end
 end

data/lib/ruby_llm/contract.rb

@@ -2,10 +2,19 @@
 
 require_relative "contract/version"
 require_relative "contract/errors"
+require_relative "contract/unknown_policy"
 require_relative "contract/types"
 
 module RubyLLM
   module Contract
+    # Rails dirs holding Step classes. Each one's eval/ subdir holds define_eval
+    # files, which define no constant, so Zeitwerk must ignore exactly those.
+    RAILS_CONTRACT_DIRS = %w[app/contracts app/steps].freeze
+    RAILS_EVAL_DIRS = RAILS_CONTRACT_DIRS.map { |dir| "#{dir}/eval" }.freeze
+
+    # Set while load_evals! runs: redefining an eval is then a reload, not a mistake.
+    RELOADING_KEY = :ruby_llm_contract_reloading
+
     class << self
       def configuration
         @configuration ||= Configuration.new
@@ -51,7 +60,7 @@ module RubyLLM
       def load_evals!(*dirs)
         dirs = dirs.flatten.compact
         if dirs.empty? && defined?(::Rails)
-          dirs = %w[app/steps/eval app/contracts/eval].filter_map do |path|
+          dirs = RAILS_EVAL_DIRS.filter_map do |path|
             full = ::Rails.root.join(path)
             full.to_s if full.exist?
           end
@@ -64,7 +73,7 @@ module RubyLLM
         eager_load_contract_dirs! if defined?(::Rails)
 
         # Clear file-sourced evals ONCE, then load ALL dirs.
-        Thread.current[:ruby_llm_contract_reloading] = true
+        Thread.current[RELOADING_KEY] = true
         eval_hosts.each do |host|
           host.clear_file_sourced_evals! if host.respond_to?(:clear_file_sourced_evals!)
         end
@@ -73,7 +82,11 @@ module RubyLLM
           Dir[File.join(d, "**", "*_eval.rb")].each { |f| load f }
         end
       ensure
-        Thread.current[:ruby_llm_contract_reloading] = false
+        Thread.current[RELOADING_KEY] = false
+      end
+
+      def reloading?
+        Thread.current[RELOADING_KEY] ? true : false
       end
 
       def normalize_candidate_config(entry)
@@ -111,7 +124,7 @@ module RubyLLM
       end
 
       def eager_load_contract_dirs!
-        %w[app/contracts app/steps].each do |path|
+        RAILS_CONTRACT_DIRS.each do |path|
           full = ::Rails.root.join(path)
           next unless full.exist?
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm-contract
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Justyna
@@ -193,6 +193,7 @@ files:
 - lib/ruby_llm/contract/step/trace.rb
 - lib/ruby_llm/contract/token_estimator.rb
 - lib/ruby_llm/contract/types.rb
+- lib/ruby_llm/contract/unknown_policy.rb
 - lib/ruby_llm/contract/version.rb
 - ruby_llm-contract.gemspec
 homepage: https://github.com/justi/ruby_llm-contract