ruby_llm-contract 0.4.2 → 0.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7f3a23f6ba5f67352d32b67ba0737c60d0112dc1db866c9988bbd5d894dcb4f
-  data.tar.gz: 7b94ae8959fd87e695063b4e94a3e7217d8bb9b93a860c574f3f1d626bb4a94d
+  metadata.gz: 502a22f4a2c8f88416bac904fb2ca370f25ba70076b3257700ae296705320314
+  data.tar.gz: '096dd32146b497b400984185185b9e2e81e6b5b53169896946a43545e368b25c'
 SHA512:
-  metadata.gz: 4abcaf1069f7e97072375027cadbcbcb2b4970a48a5d0a21cb25bc992f53cba6a3c8c6061cc24749f3162600a99017213a58e91f30b52a690deae4102ec153c9
-  data.tar.gz: 6ba8118f0ba2b14b43a5908afc5118f96a585026257a3fef97d07a232ac35442b88d6210e2a0c155396dde487f85d9ebb50f65ab104e645abd6ea38128300877
+  metadata.gz: 2111cd0c66eee5c1bec53ae4e5278aa9a79643304f3812bba65113ded58b7a42fa56b4d612461e1e5553e4cebd529417760bc07c919a52b1462498ca3ececbf3
+  data.tar.gz: 61e8112e9ec2c577d675458d53ecbae303da8db31351803d6e0758b7b7f8b6566587147efa8b889d93a955b85217ebe7d1883d6c506f53d04490a50b6448cf2a

data/CHANGELOG.md

@@ -1,5 +1,45 @@
 # Changelog
 
+## 0.4.5 (2026-03-24)
+
+Audit hardening — 18 bugs fixed across 4 audit rounds.
+
+### Fixes
+
+- **RakeTask history before abort** — `track_history` now saves all reports (pass and fail) before gating, so failed runs appear in eval history.
+- **RSpec/Minitest stub scoping** — block form `stub_step` uses thread-local overrides with real cleanup. Non-block `stub_all_steps` auto-restored by RSpec `around(:each)` hook and Minitest `setup`/`teardown`.
+- **StepAdapterOverride** — handles `context: nil` and respects string key `"adapter"`. Moved to `contract.rb` so both test frameworks share one mechanism.
+- **max_cost fail closed output estimate** — preflight uses 1x input tokens as output estimate when `max_output` not set, preventing cost bypass for output-expensive models.
+- **reset_configuration! clears overrides** — `step_adapter_overrides` now cleared on reset.
+- **CostCalculator.register_model** — validates `Numeric`, `finite?`, non-negative. Rejects NaN, Infinity, strings, nil.
+- **Pipeline token_budget** — rejects negative and zero values (parity with `timeout_ms`).
+- **track_history model fallback** — uses step DSL `model`, then `default_model` when context has no model. Handles string key `"model"`.
+- **estimate_cost / estimate_eval_cost** — falls back to step DSL model when no explicit model arg given.
+- **stub_steps string keys** — both RSpec and Minitest normalize string-keyed options with `transform_keys(:to_sym)`.
+- **DSL `:default` reset** — `model(:default)`, `temperature(:default)`, `max_cost(:default)` reset inherited parent values.
+
+## 0.4.4 (2026-03-24)
+
+- **`stub_steps` (plural)** — stub multiple steps with different responses in one block. No nesting needed. Works in RSpec and Minitest:
+  ```ruby
+  stub_steps(
+    ClassifyTicket => { response: { priority: "high" } },
+    RouteToTeam => { response: { team: "billing" } }
+  ) { TicketPipeline.run("test") }
+  ```
+
+## 0.4.3 (2026-03-24)
+
+Production feedback release — driven by ADR-0016 (real Rails 8.1 deployment).
+
+### Features
+
+- **`stub_step` block form** — `stub_step(Step, response: x) { test }` auto-resets adapter after block. Works in RSpec and Minitest. Eliminates leaked test state.
+- **Minitest per-step routing** — `stub_step(StepA, ...)` now actually routes to StepA only (was setting global adapter, ignoring step class).
+- **`track_history` in RakeTask** — `t.track_history = true` auto-appends every eval run (pass and fail) to `.eval_history/`. Drift detection without manual `save_history!` calls.
+- **`max_cost` fail closed** — unknown model pricing now refuses the call instead of silently skipping. Set `on_unknown_pricing: :warn` for old behavior.
+- **`CostCalculator.register_model`** — register pricing for custom/fine-tuned models: `register_model("ft:gpt-4o", input_per_1m: 3.0, output_per_1m: 6.0)`.
+
 ## 0.4.2 (2026-03-24)
 
 - **RakeTask lazy context** — `t.context` now accepts a Proc, resolved at task runtime (after `:environment`). Fixes adapter not being available at Rake load time in Rails apps.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ruby_llm-contract (0.4.2)
+    ruby_llm-contract (0.4.5)
       dry-types (~> 1.7)
       ruby_llm (~> 1.0)
       ruby_llm-schema (~> 0.3)
@@ -165,7 +165,7 @@ CHECKSUMS
   rubocop-ast (1.49.1) sha256=4412f3ee70f6fe4546cc489548e0f6fcf76cafcfa80fa03af67098ffed755035
   ruby-progressbar (1.13.0) sha256=80fc9c47a9b640d6834e0dc7b3c94c9df37f08cb072b7761e4a71e22cff29b33
   ruby_llm (1.14.0) sha256=57c6f7034fc4a44504ea137d70f853b07824f1c1cdbe774ab3ab3522e7098deb
-  ruby_llm-contract (0.4.2)
+  ruby_llm-contract (0.4.5)
   ruby_llm-schema (0.3.0) sha256=a591edc5ca1b7f0304f0e2261de61ba4b3bea17be09f5cf7558153adfda3dec6
   unicode-display_width (3.2.0) sha256=0cdd96b5681a5949cdbc2c55e7b420facae74c4aaf9a9815eee1087cb1853c42
   unicode-emoji (4.2.0) sha256=519e69150f75652e40bf736106cfbc8f0f73aa3fb6a65afe62fefa7f80b0f80f

data/lib/ruby_llm/contract/cost_calculator.rb

@@ -3,6 +3,36 @@
 module RubyLLM
   module Contract
     module CostCalculator
+      # Simple struct for custom-registered model pricing
+      RegisteredModel = Struct.new(:input_price_per_million, :output_price_per_million, keyword_init: true)
+
+      @custom_models = {}
+
+      # Register pricing for custom or fine-tuned models not in the RubyLLM registry.
+      #
+      #   CostCalculator.register_model("ft:gpt-4o-custom",
+      #     input_per_1m: 3.0, output_per_1m: 6.0)
+      #
+      def self.register_model(model_name, input_per_1m:, output_per_1m:)
+        validate_price!(:input_per_1m, input_per_1m)
+        validate_price!(:output_per_1m, output_per_1m)
+
+        @custom_models[model_name] = RegisteredModel.new(
+          input_price_per_million: input_per_1m,
+          output_price_per_million: output_per_1m
+        )
+      end
+
+      # Remove a previously registered custom model. Mainly useful in tests.
+      def self.unregister_model(model_name)
+        @custom_models.delete(model_name)
+      end
+
+      # Reset all custom model registrations. Mainly useful in tests.
+      def self.reset_custom_models!
+        @custom_models.clear
+      end
+
       def self.calculate(model_name:, usage:)
         return nil unless model_name && usage.is_a?(Hash)
 
@@ -25,6 +55,10 @@ module RubyLLM
       end
 
       def self.find_model(model_name)
+        # Check custom registry first
+        custom = @custom_models[model_name]
+        return custom if custom
+
         return nil unless defined?(RubyLLM)
 
         RubyLLM.models.find(model_name)
@@ -32,7 +66,13 @@ module RubyLLM
         nil
       end
 
-      private_class_method :compute_cost, :token_cost, :find_model
+      def self.validate_price!(name, value)
+        unless value.is_a?(Numeric) && value.finite? && !value.negative?
+          raise ArgumentError, "#{name} must be a finite non-negative number, got #{value.inspect}"
+        end
+      end
+
+      private_class_method :compute_cost, :token_cost, :find_model, :validate_price!
     end
   end
 end

data/lib/ruby_llm/contract/minitest.rb

@@ -5,6 +5,20 @@ require "ruby_llm/contract"
 module RubyLLM
   module Contract
     module MinitestHelpers
+      # Snapshot adapter before each test so teardown can restore it.
+      def setup
+        super if defined?(super)
+        @_contract_original_adapter = RubyLLM::Contract.configuration.default_adapter
+      end
+
+      # Auto-cleanup: clear overrides AND restore original adapter.
+      # Prevents both non-block stub_step and stub_all_steps from leaking.
+      def teardown
+        RubyLLM::Contract.step_adapter_overrides.clear
+        RubyLLM::Contract.configuration.default_adapter = @_contract_original_adapter
+        super if defined?(super)
+      end
+
       def assert_satisfies_contract(result, msg = nil)
         assert result.ok?, msg || "Expected step result to satisfy contract, " \
           "but got status: #{result.status}. Errors: #{result.validation_errors.join(", ")}"
@@ -33,13 +47,113 @@ module RubyLLM
         report
       end
 
-      def stub_step(step_class, response: nil, responses: nil)
+      # Stub a specific step to return a canned response without API calls.
+      # Routes per-step — other steps are not affected.
+      #
+      #   stub_step(ClassifyTicket, response: { priority: "high" })
+      #
+      # Supports an optional block form — the override is removed after the
+      # block returns (even if it raises):
+      #
+      #   stub_step(ClassifyTicket, response: data) do
+      #     result = ClassifyTicket.run("test")
+      #   end
+      #   # ClassifyTicket.run no longer stubbed
+      #
+      def stub_step(step_class, response: nil, responses: nil, &block)
+        adapter = if responses
+                    Adapters::Test.new(responses: responses)
+                  else
+                    Adapters::Test.new(response: response)
+                  end
+
+        overrides = RubyLLM::Contract.step_adapter_overrides
+        previous = overrides[step_class]
+        overrides[step_class] = adapter
+
+        if block
+          begin
+            yield
+          ensure
+            if previous
+              overrides[step_class] = previous
+            else
+              overrides.delete(step_class)
+            end
+          end
+        end
+      end
+
+      # Stub multiple steps at once with different responses.
+      # Takes a hash of step_class => options. Requires a block.
+      #
+      #   stub_steps(
+      #     ClassifyTicket => { response: { priority: "high" } },
+      #     RouteToTeam => { response: { team: "billing" } }
+      #   ) do
+      #     result = TicketPipeline.run("test")
+      #   end
+      #
+      def stub_steps(stubs, &block)
+        raise ArgumentError, "stub_steps requires a block" unless block
+
+        overrides = RubyLLM::Contract.step_adapter_overrides
+        previous = {}
+
+        stubs.each do |step_class, opts|
+          opts = opts.transform_keys(&:to_sym)
+          adapter = if opts[:responses]
+                      Adapters::Test.new(responses: opts[:responses])
+                    else
+                      Adapters::Test.new(response: opts[:response])
+                    end
+          previous[step_class] = overrides[step_class]
+          overrides[step_class] = adapter
+        end
+
+        begin
+          yield
+        ensure
+          stubs.each_key do |step_class|
+            if previous[step_class]
+              overrides[step_class] = previous[step_class]
+            else
+              overrides.delete(step_class)
+            end
+          end
+        end
+      end
+
+      # Set a global test adapter for ALL steps.
+      #
+      #   stub_all_steps(response: { default: true })
+      #
+      # Supports an optional block form — the previous adapter is restored
+      # after the block returns (even if it raises):
+      #
+      #   stub_all_steps(response: { default: true }) do
+      #     # all steps use test adapter
+      #   end
+      #   # original adapter restored
+      #
+      def stub_all_steps(response: nil, responses: nil, &block)
         adapter = if responses
                     Adapters::Test.new(responses: responses)
                   else
                     Adapters::Test.new(response: response)
                   end
-        RubyLLM::Contract.configure { |c| c.default_adapter = adapter }
+
+        if block
+          previous = RubyLLM::Contract.configuration.default_adapter
+          begin
+            RubyLLM::Contract.configuration.default_adapter = adapter
+            yield
+          ensure
+            RubyLLM::Contract.configuration.default_adapter = previous
+          end
+        else
+          RubyLLM::Contract.configure { |c| c.default_adapter = adapter }
+        end
       end
     end
   end

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

@@ -29,7 +29,11 @@ module RubyLLM
           end
 
           def token_budget(limit = nil)
-            return @token_budget = limit if limit
+            if limit
+              raise ArgumentError, "token_budget must be positive, got #{limit}" unless limit.positive?
+
+              return @token_budget = limit
+            end
 
             @token_budget
           end

data/lib/ruby_llm/contract/rake_task.rb

@@ -7,7 +7,7 @@ module RubyLLM
   module Contract
     class RakeTask < ::Rake::TaskLib
       attr_accessor :name, :context, :fail_on_empty, :minimum_score, :maximum_cost,
-                    :eval_dirs, :save_baseline, :fail_on_regression
+                    :eval_dirs, :save_baseline, :fail_on_regression, :track_history
 
       def initialize(name = :"ruby_llm_contract:eval", &block)
         super()
@@ -19,6 +19,7 @@ module RubyLLM
         @eval_dirs = []      # directories to load eval files from (non-Rails)
         @save_baseline = false
         @fail_on_regression = false
+        @track_history = false
         block&.call(self)
         define_task
       end
@@ -47,18 +48,23 @@ module RubyLLM
           suite_cost = 0.0
 
           passed_reports = []
+          all_reports = []
 
           results.each do |host, reports|
             puts "\n#{host.name || host.to_s}"
             reports.each_value do |report|
               report.print_summary
               suite_cost += report.total_cost
+              all_reports << [host, report]
               report_ok = report_meets_score?(report) && !check_regression(report)
               gate_passed = false unless report_ok
               passed_reports << report if report_ok
             end
           end
 
+          # Save history BEFORE gating — failures are valuable trend data (ADR-0016 F3)
+          save_all_history!(all_reports, context) if @track_history
+
           if @maximum_cost && suite_cost > @maximum_cost
             abort "\nEval suite FAILED: total cost $#{format("%.4f", suite_cost)} " \
                   "exceeds budget $#{format("%.4f", @maximum_cost)}"
@@ -68,6 +74,7 @@ module RubyLLM
 
           # Save baselines only after ALL gates pass
           passed_reports.each { |r| save_baseline!(r) } if @save_baseline
+
           puts "\nAll evals passed."
         end
       end
@@ -98,6 +105,18 @@ module RubyLLM
         puts "  Baseline saved: #{path}"
       end
 
+      def save_all_history!(host_reports, context)
+        context_model = (context[:model] || context["model"]) if context.is_a?(Hash)
+        host_reports.each do |host, report|
+          # Model priority: context > step DSL > default config
+          model = context_model
+          model ||= (host.model if host.respond_to?(:model))
+          model ||= RubyLLM::Contract.configuration.default_model rescue nil
+          path = report.save_history!(model: model)
+          puts "  History saved: #{path}"
+        end
+      end
+
       def task_prerequisites
         defined?(::Rails) ? [:environment] : []
       end

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

@@ -12,11 +12,77 @@ module RubyLLM
         #
         # Only affects the specified step — other steps are not affected.
         #
-        def stub_step(step_class, response: nil, responses: nil)
+        # With a block, the stub is scoped — cleaned up after the block:
+        #
+        #   stub_step(ClassifyTicket, response: data) do
+        #     # only stubbed inside this block
+        #   end
+        #   # ClassifyTicket no longer stubbed
+        #
+        # Without a block, the stub lives until the RSpec example ends.
+        #
+        def stub_step(step_class, response: nil, responses: nil, &block)
           adapter = build_test_adapter(response: response, responses: responses)
-          allow(step_class).to receive(:run).and_wrap_original do |original, input, **kwargs|
-            context = (kwargs[:context] || {}).merge(adapter: adapter)
-            original.call(input, context: context)
+
+          if block
+            # Block form: use thread-local overrides with save/restore for real scoping
+            overrides = RubyLLM::Contract.step_adapter_overrides
+            previous = overrides[step_class]
+            overrides[step_class] = adapter
+            begin
+              yield
+            ensure
+              if previous
+                overrides[step_class] = previous
+              else
+                overrides.delete(step_class)
+              end
+            end
+          else
+            # Non-block: use RSpec allow (auto-cleaned after example)
+            allow(step_class).to receive(:run).and_wrap_original do |original, input, **kwargs|
+              context = kwargs[:context] || {}
+              unless context.key?(:adapter) || context.key?("adapter")
+                context = context.merge(adapter: adapter)
+              end
+              original.call(input, context: context)
+            end
+          end
+        end
+
+        # Stub multiple steps at once with different responses.
+        # Takes a hash of step_class => options. Requires a block.
+        #
+        #   stub_steps(
+        #     ClassifyTicket => { response: { priority: "high" } },
+        #     RouteToTeam => { response: { team: "billing" } }
+        #   ) do
+        #     result = TicketPipeline.run("test")
+        #   end
+        #
+        def stub_steps(stubs, &block)
+          raise ArgumentError, "stub_steps requires a block" unless block
+
+          overrides = RubyLLM::Contract.step_adapter_overrides
+          previous = {}
+
+          stubs.each do |step_class, opts|
+            opts = opts.transform_keys(&:to_sym)
+            adapter = build_test_adapter(**opts)
+            previous[step_class] = overrides[step_class]
+            overrides[step_class] = adapter
+          end
+
+          begin
+            yield
+          ensure
+            stubs.each_key do |step_class|
+              if previous[step_class]
+                overrides[step_class] = previous[step_class]
+              else
+                overrides.delete(step_class)
+              end
+            end
           end
         end
 
@@ -24,9 +90,28 @@ module RubyLLM
         #
         #   stub_all_steps(response: { default: true })
         #
-        def stub_all_steps(response: nil, responses: nil)
+        # Supports an optional block form — the previous adapter is restored
+        # after the block returns (even if it raises):
+        #
+        #   stub_all_steps(response: { default: true }) do
+        #     # all steps use test adapter
+        #   end
+        #   # original adapter restored
+        #
+        def stub_all_steps(response: nil, responses: nil, &block)
           adapter = build_test_adapter(response: response, responses: responses)
-          RubyLLM::Contract.configure { |c| c.default_adapter = adapter }
+
+          if block
+            previous = RubyLLM::Contract.configuration.default_adapter
+            begin
+              RubyLLM::Contract.configuration.default_adapter = adapter
+              yield
+            ensure
+              RubyLLM::Contract.configuration.default_adapter = previous
+            end
+          else
+            RubyLLM::Contract.configure { |c| c.default_adapter = adapter }
+          end
         end
 
         private

data/lib/ruby_llm/contract/rspec.rb

@@ -8,4 +8,17 @@ require_relative "rspec/helpers"
 
 RSpec.configure do |config|
   config.include RubyLLM::Contract::RSpec::Helpers
+
+  # Auto-cleanup: snapshot adapter before each example, restore after.
+  # Prevents non-block stub_all_steps from leaking between examples.
+  config.around(:each) do |example|
+    original_adapter = RubyLLM::Contract.configuration.default_adapter
+    original_overrides = RubyLLM::Contract.step_adapter_overrides.dup
+    begin
+      example.run
+    ensure
+      RubyLLM::Contract.configuration.default_adapter = original_adapter
+      RubyLLM::Contract.step_adapter_overrides.replace(original_overrides)
+    end
+  end
 end if defined?(::RSpec)

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

@@ -24,7 +24,7 @@ module RubyLLM
           end
 
           def estimate_cost(input:, model: nil)
-            model_name = model || RubyLLM::Contract.configuration.default_model
+            model_name = model || (self.model if respond_to?(:model)) || RubyLLM::Contract.configuration.default_model
             messages = build_messages(input)
             input_tokens = TokenEstimator.estimate(messages)
             output_tokens = max_output || 256 # conservative default
@@ -46,7 +46,8 @@ module RubyLLM
             defn = send(:all_eval_definitions)[eval_name.to_s]
             raise ArgumentError, "No eval '#{eval_name}' defined" unless defn
 
-            model_list = models || [RubyLLM::Contract.configuration.default_model].compact
+            step_model = (self.model if respond_to?(:model))
+            model_list = models || [step_model || RubyLLM::Contract.configuration.default_model].compact
             cases = defn.build_dataset.cases
 
             model_list.each_with_object({}) do |model_name, result|
@@ -117,6 +118,7 @@ module RubyLLM
               prompt_block: prompt, contract_definition: effective_contract,
               adapter: adapter, model: model, output_schema: output_schema,
               max_output: max_output, max_input: max_input, max_cost: max_cost,
+              on_unknown_pricing: on_unknown_pricing,
               temperature: effective_temp, extra_options: extra_options
             ).call(input)
           rescue ArgumentError => e

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

@@ -111,48 +111,83 @@ module RubyLLM
           end
         end
 
-        def max_cost(amount = nil)
+        def max_cost(amount = nil, on_unknown_pricing: nil)
+          if amount == :default
+            @max_cost = nil
+            @max_cost_explicitly_unset = true
+            @on_unknown_pricing = nil
+            return nil
+          end
+
           if amount
             unless amount.is_a?(Numeric) && amount.positive?
               raise ArgumentError, "max_cost must be positive, got #{amount}"
             end
 
-            return @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
+
+            @max_cost_explicitly_unset = false
+            @max_cost = amount
+            @on_unknown_pricing = on_unknown_pricing || :refuse
+            return @max_cost
           end
 
-          if defined?(@max_cost)
-            @max_cost
-          elsif superclass.respond_to?(:max_cost)
-            superclass.max_cost
+          return @max_cost if defined?(@max_cost) && !@max_cost_explicitly_unset
+          return nil if @max_cost_explicitly_unset
+
+          superclass.max_cost if superclass.respond_to?(:max_cost)
+        end
+
+        def on_unknown_pricing
+          if defined?(@on_unknown_pricing)
+            @on_unknown_pricing
+          elsif superclass.respond_to?(:on_unknown_pricing)
+            superclass.on_unknown_pricing
+          else
+            :refuse
           end
         end
 
         def model(name = nil)
+          if name == :default
+            @model = nil
+            @model_explicitly_unset = true
+            return nil
+          end
+
           if name
+            @model_explicitly_unset = false
             return @model = name
           end
 
-          if defined?(@model)
-            @model
-          elsif superclass.respond_to?(:model)
-            superclass.model
-          end
+          return @model if defined?(@model) && !@model_explicitly_unset
+          return nil if @model_explicitly_unset
+
+          superclass.model if superclass.respond_to?(:model)
         end
 
         def temperature(value = nil)
+          if value == :default
+            @temperature = nil
+            @temperature_explicitly_unset = true
+            return nil
+          end
+
           if value
             unless value.is_a?(Numeric) && value >= 0 && value <= 2
               raise ArgumentError, "temperature must be 0.0-2.0, got #{value}"
             end
 
+            @temperature_explicitly_unset = false
             return @temperature = value
           end
 
-          if defined?(@temperature)
-            @temperature
-          elsif superclass.respond_to?(:temperature)
-            superclass.temperature
-          end
+          return @temperature if defined?(@temperature) && !@temperature_explicitly_unset
+          return nil if @temperature_explicitly_unset
+
+          superclass.temperature if superclass.respond_to?(:temperature)
         end
 
         def around_call(&block)

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

@@ -28,16 +28,22 @@ module RubyLLM
           errors
         end
 
+        # Default output estimate when max_output is not set.
+        # Uses input token count as a conservative proxy — most LLM responses
+        # are shorter than the input, so this overestimates slightly.
+        # Without this, output cost is zero and max_cost can be bypassed
+        # for models expensive on completion side.
+        DEFAULT_OUTPUT_RATIO = 1
+
         def append_cost_error(estimated, errors)
-          estimated_output = effective_max_output || 0
+          estimated_output = effective_max_output || (estimated * DEFAULT_OUTPUT_RATIO)
           estimated_cost = CostCalculator.calculate(
             model_name: @model,
             usage: { input_tokens: estimated, output_tokens: estimated_output }
           )
 
           if estimated_cost.nil?
-            warn "[ruby_llm-contract] max_cost is configured but model '#{@model}' " \
-                 "has no pricing data — cost limit not enforced"
+            handle_unknown_pricing(errors)
           elsif estimated_cost > @max_cost
             errors << "Cost limit exceeded: estimated $#{format("%.6f", estimated_cost)} " \
                       "(#{estimated} input + #{estimated_output} output tokens), " \
@@ -45,6 +51,17 @@ module RubyLLM
           end
         end
 
+        def handle_unknown_pricing(errors)
+          if @on_unknown_pricing == :warn
+            warn "[ruby_llm-contract] max_cost is configured but model '#{@model}' " \
+                 "has no pricing data — cost limit not enforced"
+          else
+            errors << "max_cost is set but model '#{@model}' has no pricing data. " \
+                      "Register pricing via CostCalculator.register_model or set " \
+                      "on_unknown_pricing: :warn to proceed without cost checks."
+          end
+        end
+
         def build_limit_result(messages, estimated, errors)
           Result.new(
             status: :limit_exceeded,

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

@@ -8,7 +8,8 @@ module RubyLLM
 
         def initialize(input_type:, output_type:, prompt_block:, contract_definition:,
                        adapter:, model:, output_schema: nil, max_output: nil,
-                       max_input: nil, max_cost: nil, temperature: nil, extra_options: {})
+                       max_input: nil, max_cost: nil, on_unknown_pricing: :refuse,
+                       temperature: nil, extra_options: {})
           @input_type = input_type
           @output_type = output_type
           @prompt_block = prompt_block
@@ -19,6 +20,7 @@ module RubyLLM
           @max_output = max_output
           @max_input = max_input
           @max_cost = max_cost
+          @on_unknown_pricing = on_unknown_pricing
           @temperature = temperature
           @extra_options = extra_options
         end

data/lib/ruby_llm/contract/version.rb

@@ -2,6 +2,6 @@
 
 module RubyLLM
   module Contract
-    VERSION = "0.4.2"
+    VERSION = "0.4.5"
   end
 end

data/lib/ruby_llm/contract.rb

@@ -18,6 +18,7 @@ module RubyLLM
 
       def reset_configuration!
         @configuration = Configuration.new
+        step_adapter_overrides.clear
       end
 
       # --- Eval host registry ---
@@ -40,6 +41,15 @@ module RubyLLM
         @eval_hosts = []
       end
 
+      # Thread-local per-step adapter overrides used by test helpers (RSpec + Minitest).
+      def step_adapter_overrides
+        Thread.current[:ruby_llm_contract_step_overrides] ||= {}
+      end
+
+      def step_adapter_overrides=(map)
+        Thread.current[:ruby_llm_contract_step_overrides] = map
+      end
+
       def load_evals!(*dirs)
         dirs = dirs.flatten.compact
         if dirs.empty? && defined?(::Rails)
@@ -102,6 +112,21 @@ module RubyLLM
         nil
       end
     end
+
+    # One-time prepend on Step::Base that checks the override map before
+    # falling through to the normal adapter resolution.
+    # Used by both RSpec and Minitest test helpers.
+    module StepAdapterOverride
+      def run(input, context: {})
+        context = context || {}
+        overrides = RubyLLM::Contract.step_adapter_overrides
+        unless overrides.empty? || context.key?(:adapter) || context.key?("adapter")
+          override = overrides[self]
+          context = context.merge(adapter: override) if override
+        end
+        super(input, context: context)
+      end
+    end
   end
 end
 
@@ -126,3 +151,6 @@ require_relative "contract/pipeline"
 require_relative "contract/eval"
 require_relative "contract/dsl"
 require_relative "contract/railtie" if defined?(Rails::Railtie)
+
+# Prepend after Step::Base is loaded
+RubyLLM::Contract::Step::Base.singleton_class.prepend(RubyLLM::Contract::StepAdapterOverride)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm-contract
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.5
 platform: ruby
 authors:
 - Justyna