ruby_llm-contract 0.7.1 → 0.8.0

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

@@ -200,6 +200,44 @@ module RubyLLM
           superclass.temperature if superclass.respond_to?(:temperature)
         end
 
+        def thinking(effort: nil, budget: nil)
+          if effort == :default
+            @thinking = nil
+            @thinking_explicitly_unset = true
+            return nil
+          end
+
+          if effort || budget
+            @thinking_explicitly_unset = false
+            return @thinking = { effort: effort, budget: budget }.compact
+          end
+
+          return @thinking if defined?(@thinking) && !@thinking_explicitly_unset
+          return nil if @thinking_explicitly_unset
+
+          superclass.thinking if superclass.respond_to?(:thinking)
+        end
+
+        def reasoning_effort(value = nil)
+          return (thinking && thinking[:effort]) if value.nil?
+
+          # Alias is scoped to the effort dimension only. `:default` on the
+          # alias clears effort but PRESERVES any previously-set budget — the
+          # name does not suggest "wipe the whole thinking config." Use the
+          # full `thinking(effort: :default)` to clear everything.
+          if value == :default
+            current_budget = thinking && thinking[:budget]
+            if current_budget
+              @thinking_explicitly_unset = false
+              @thinking = { budget: current_budget }
+              return nil
+            end
+            return thinking(effort: :default)
+          end
+
+          thinking(effort: value)
+        end
+
         def around_call(&block)
           if block
             return @around_call = block

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

@@ -22,7 +22,7 @@ module RubyLLM
         def collect_limit_errors(estimated)
           errors = []
           if max_input && estimated > max_input
-            errors << "Input token limit exceeded: estimated #{estimated} tokens, max #{max_input}"
+            errors << "Input token limit exceeded: estimated #{estimated} tokens (heuristic ±30%), max #{max_input}"
           end
           append_cost_error(estimated, errors) if max_cost
           errors
@@ -46,7 +46,7 @@ module RubyLLM
             handle_unknown_pricing(errors)
           elsif estimated_cost > max_cost
             errors << "Cost limit exceeded: estimated $#{format("%.6f", estimated_cost)} " \
-                      "(#{estimated} input + #{estimated_output} output tokens), " \
+                      "(#{estimated} input + #{estimated_output} output tokens, heuristic ±30%), " \
                       "max $#{format("%.6f", max_cost)}"
           end
         end

data/lib/ruby_llm/contract/token_estimator.rb

@@ -2,12 +2,29 @@
 
 module RubyLLM
   module Contract
+    # Pre-flight token estimation for `max_input` / `max_cost` budget gating.
+    #
+    # IMPORTANT — heuristic only. This is NOT an accurate tokenizer.
+    # The estimate uses a fixed `length / CHARS_PER_TOKEN` ratio:
+    #
+    #   - Accurate to ±30% for English prose with mainstream OpenAI / Anthropic models
+    #   - Worse for non-English text, code, structured data, and unusual scripts
+    #   - Useless for models with very different tokenizers (e.g. some open-source models)
+    #
+    # RubyLLM 1.14 ships no pre-flight tokenizer either; once the API call
+    # returns, `RubyLLM::Tokens` provides accurate counts from provider usage
+    # data. This estimator is for the *pre-flight refusal* path only — its job
+    # is to answer "is this call almost certainly within budget?" with enough
+    # accuracy that runaway prompts get caught, while accepting that the
+    # boundary cases will be wrong.
+    #
+    # Refusal messages from `LimitChecker` carry an "(heuristic)" suffix so
+    # adopters know the number is estimated, not measured.
     module TokenEstimator
-      # Heuristic: ~4 characters per token for English text.
-      # This is a rough estimate — actual tokenization varies by model and content.
-      # Intentionally conservative (overestimates slightly) to avoid surprise costs.
       CHARS_PER_TOKEN = 4
 
+      # Heuristic estimate. Returns an integer token count.
+      # See module docstring for accuracy caveats.
       def self.estimate(messages)
         return 0 unless messages.is_a?(Array)
 

data/lib/ruby_llm/contract/version.rb

@@ -2,6 +2,6 @@
 
 module RubyLLM
   module Contract
-    VERSION = "0.7.1"
+    VERSION = "0.8.0"
   end
 end

data/ruby_llm-contract.gemspec

@@ -7,10 +7,11 @@ Gem::Specification.new do |spec|
   spec.version = RubyLLM::Contract::VERSION
   spec.authors = ["Justyna"]
 
-  spec.summary = "Know which LLM model to use, what it costs, and when accuracy drops"
-  spec.description = "Compare LLM models by accuracy and cost. Regression-test prompts in CI. " \
-                     "Start on nano, auto-escalate to bigger models when quality drops. " \
-                     "Companion gem for ruby_llm."
+  spec.summary = "Contracts + Evals for ruby_llm"
+  spec.description = "Wraps RubyLLM::Chat with input/output contracts, business-rule validation, " \
+                     "retry with model escalation on validation failure, pre-flight cost ceilings, " \
+                     "and an evaluation framework. Sibling abstraction to RubyLLM::Agent — same " \
+                     "niche (reusable class-based prompts), wider contract."
   spec.homepage = "https://github.com/justi/ruby_llm-contract"
   spec.license = "MIT"
   spec.required_ruby_version = ">= 3.2.0"
@@ -30,6 +31,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "dry-types", "~> 1.7"
-  spec.add_dependency "ruby_llm", "~> 1.0"
+  spec.add_dependency "ruby_llm", "~> 1.12"
   spec.add_dependency "ruby_llm-schema", "~> 0.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm-contract
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.0
 platform: ruby
 authors:
 - Justyna
@@ -29,14 +29,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.12'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.12'
 - !ruby/object:Gem::Dependency
   name: ruby_llm-schema
   requirement: !ruby/object:Gem::Requirement
@@ -51,9 +51,10 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.3'
-description: Compare LLM models by accuracy and cost. Regression-test prompts in CI.
-  Start on nano, auto-escalate to bigger models when quality drops. Companion gem
-  for ruby_llm.
+description: Wraps RubyLLM::Chat with input/output contracts, business-rule validation,
+  retry with model escalation on validation failure, pre-flight cost ceilings, and
+  an evaluation framework. Sibling abstraction to RubyLLM::Agent — same niche (reusable
+  class-based prompts), wider contract.
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -69,15 +70,12 @@ files:
 - README.md
 - Rakefile
 - examples/00_basics.rb
-- examples/01_classify_threads.rb
-- examples/02_generate_comment.rb
-- examples/03_target_audience.rb
-- examples/04_real_llm.rb
-- examples/05_output_schema.rb
-- examples/07_keyword_extraction.rb
-- examples/08_translation.rb
-- examples/09_eval_dataset.rb
-- examples/10_reddit_full_showcase.rb
+- examples/01_fallback_showcase.rb
+- examples/02_real_llm_minimal.rb
+- examples/03_summarize_with_keywords.rb
+- examples/04_summarize_and_translate.rb
+- examples/05_eval_dataset.rb
+- examples/06_retry_variants.rb
 - examples/README.md
 - lib/ruby_llm/contract.rb
 - lib/ruby_llm/contract/adapters.rb
@@ -208,5 +206,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.7
 specification_version: 4
-summary: Know which LLM model to use, what it costs, and when accuracy drops
+summary: Contracts + Evals for ruby_llm
 test_files: []

data/examples/01_classify_threads.rb

@@ -1,220 +0,0 @@
-# frozen_string_literal: true
-
-# =============================================================================
-# EXAMPLE 1: Thread Classification (PROMO / FILLER / SKIP)
-#
-# Real-world case: A Reddit promotion planner needs to classify threads
-# into PROMO (worth commenting with a product link), FILLER (worth a
-# genuine comment without product mention), or SKIP (irrelevant).
-# =============================================================================
-
-require_relative "../lib/ruby_llm/contract"
-
-# =============================================================================
-# BEFORE: Legacy approach (inline heredoc + ad-hoc validation)
-# =============================================================================
-#
-# In the legacy codebase, this lives across multiple concern files:
-# - classification_prompts.rb (prompt building)
-# - thread_classification.rb (LLM calling + parsing)
-# - llm_result_mapper.rb (ID matching with positional fallback)
-#
-# ```ruby
-# # classification_prompts.rb
-# def build_classify_prompt(items)
-#   <<~PROMPT
-#     #{classify_product_header}
-#     #{classify_sitemap_section}
-#     Classify each Reddit thread below for this product's promotion campaign.
-#
-#     For each thread, decide:
-#     #{classify_decision_rules}
-#
-#     IMPORTANT: Be careful with PROMO. Follow these rules:
-#     #{classify_promo_caution_rules}
-#
-#     Also provide:
-#     #{classify_output_fields}
-#
-#     Threads:
-#     #{items.to_json}
-#   PROMPT
-# end
-#
-# # thread_classification.rb
-# def classify_batch_via_llm(batch)
-#   items = build_classify_items(batch)
-#   prompt = build_classify_prompt(items)
-#   response = ai_call(prompt, schema: classify_response_schema)
-#   parsed = parse_llm_json(response)
-#   # Manual ID matching with positional fallback (masks errors!)
-#   map_llm_results_by_id(items, parsed["threads"])
-# end
-# ```
-#
-# PROBLEMS:
-# - Prompt is a string concatenation of 6 helper methods
-# - No contract on output — if model returns wrong enum, it silently propagates
-# - ID matching has a positional fallback that masks when model rewrites IDs
-# - No way to test prompt quality without hitting the API
-# - Change one line in classify_promo_caution_rules → no idea what broke
-
-# =============================================================================
-# AFTER: ruby_llm-contract approach
-# =============================================================================
-
-class ClassifyThreads < RubyLLM::Contract::Step::Base
-  input_type  RubyLLM::Contract::Types::Array.of(RubyLLM::Contract::Types::Hash)
-  output_type RubyLLM::Contract::Types::Array.of(RubyLLM::Contract::Types::Hash)
-
-  prompt do
-    system "You classify Reddit threads for a product promotion campaign."
-
-    rule "For each thread, classify as PROMO, FILLER, or SKIP."
-    rule "PROMO: thread author has a problem where the product helps naturally."
-    rule "FILLER: related to domain, good for a genuine comment without product mention."
-    rule "SKIP: irrelevant, low engagement, hostile to recommendations, grief/politics."
-    rule "Return a JSON array with id, classification, relevance_score (0-10), and thread_intent."
-    rule "thread_intent must be one of: seeking_help, sharing, discussion, venting."
-
-    section "SCORING GUIDE", <<~GUIDE
-      8-10: Clear problem/situation the product solves
-      5-7: Author is in target audience, link would fit naturally
-      2-4: Same broad domain but weak connection
-      0-1: Irrelevant
-    GUIDE
-
-    user "{input}"
-  end
-
-  # Structural: every input ID must appear in output
-  validate("all thread IDs must match input") do |output, input|
-    output.map { |r| r[:id] }.sort == input.map { |t| t[:id] }.sort
-  end
-
-  # Enum: classification must be valid
-  validate("classification must be PROMO, FILLER, or SKIP") do |output|
-    output.all? { |r| %w[PROMO FILLER SKIP].include?(r[:classification]) }
-  end
-
-  # Consistency: PROMO threads must have decent relevance
-  validate("PROMO threads must have relevance_score >= 5") do |output|
-    output.select { |r| r[:classification] == "PROMO" }
-          .all? { |r| r[:relevance_score].is_a?(Integer) && r[:relevance_score] >= 5 }
-  end
-
-  # Enum: thread_intent must be valid
-  validate("thread_intent must be valid") do |output|
-    valid = %w[seeking_help sharing discussion venting]
-    output.all? { |r| valid.include?(r[:thread_intent]) }
-  end
-end
-
-# =============================================================================
-# AFTER + SCHEMA: output_schema replaces structural invariants
-#
-# Compare with the version above:
-# - classification enum → schema
-# - thread_intent enum → schema
-# - relevance_score type/range → schema
-# - ID matching → still an invariant (cross-validation with input)
-# - PROMO score check → still an invariant (conditional logic)
-# =============================================================================
-
-class ClassifyThreadsWithSchema < RubyLLM::Contract::Step::Base
-  input_type RubyLLM::Contract::Types::Array.of(RubyLLM::Contract::Types::Hash)
-
-  output_schema do
-    array :threads do
-      string :id
-      string :classification, enum: %w[PROMO FILLER SKIP]
-      integer :relevance_score, minimum: 0, maximum: 10
-      string :thread_intent, enum: %w[seeking_help sharing discussion venting]
-    end
-  end
-
-  prompt do
-    system "You classify Reddit threads for a product promotion campaign."
-
-    rule "For each thread, classify as PROMO, FILLER, or SKIP."
-    rule "PROMO: thread author has a problem where the product helps naturally."
-    rule "FILLER: related to domain, good for a genuine comment without product mention."
-    rule "SKIP: irrelevant, low engagement, hostile to recommendations, grief/politics."
-    rule "Return JSON with a threads array. Each entry: id, classification, relevance_score (0-10), thread_intent."
-    rule "thread_intent must be one of: seeking_help, sharing, discussion, venting."
-
-    section "SCORING GUIDE", <<~GUIDE
-      8-10: Clear problem/situation the product solves
-      5-7: Author is in target audience, link would fit naturally
-      2-4: Same broad domain but weak connection
-      0-1: Irrelevant
-    GUIDE
-
-    user "{input}"
-  end
-
-  # Only custom business logic — structural constraints are in the schema
-  validate("all thread IDs must match input") do |output, input|
-    output[:threads].map { |r| r[:id] }.sort == input.map { |t| t[:id] }.sort
-  end
-
-  validate("PROMO threads must have relevance_score >= 5") do |output|
-    output[:threads].select { |r| r[:classification] == "PROMO" }
-                    .all? { |r| r[:relevance_score] >= 5 }
-  end
-end
-
-# =============================================================================
-# DEMO: Run with test adapter
-# =============================================================================
-
-sample_threads = [
-  { id: "t1", subreddit: "crochet", title: "spent way too much on yarn this month lol", selftext: "anyone else?" },
-  { id: "t2", subreddit: "gaming", title: "my cat destroyed my controller", selftext: "RIP" },
-  { id: "t3", subreddit: "deals", title: "best craft supply deals?", selftext: "looking for yarn and fabric sales" }
-]
-
-# Happy path — valid response
-valid_response = [
-  { id: "t1", classification: "PROMO", relevance_score: 7, thread_intent: "venting", matched_page: "/yarn-deals" },
-  { id: "t2", classification: "SKIP", relevance_score: 1, thread_intent: "venting", matched_page: "" },
-  { id: "t3", classification: "PROMO", relevance_score: 9, thread_intent: "seeking_help", matched_page: "/craft-deals" }
-].to_json
-
-adapter = RubyLLM::Contract::Adapters::Test.new(response: valid_response)
-result = ClassifyThreads.run(sample_threads, context: { adapter: adapter, model: "gpt-5-mini" })
-
-puts "=== HAPPY PATH ==="
-puts "Status: #{result.status}"
-puts "Parsed output: #{result.parsed_output.map { |r| "#{r[:id]}=#{r[:classification]}" }.join(", ")}"
-puts "Validation errors: #{result.validation_errors}"
-puts
-
-# Bad path — model returns wrong enum
-bad_response = [
-  { id: "t1", classification: "MAYBE", relevance_score: 7, thread_intent: "venting" },
-  { id: "t2", classification: "SKIP", relevance_score: 1, thread_intent: "venting" },
-  { id: "t3", classification: "PROMO", relevance_score: 9, thread_intent: "seeking_help" }
-].to_json
-
-bad_adapter = RubyLLM::Contract::Adapters::Test.new(response: bad_response)
-result = ClassifyThreads.run(sample_threads, context: { adapter: bad_adapter })
-
-puts "=== BAD ENUM ==="
-puts "Status: #{result.status}"
-puts "Validation errors: #{result.validation_errors}"
-puts
-
-# Bad path — model rewrites IDs (the silent bug legacy code masked with positional fallback)
-rewritten_ids_response = [
-  { id: "thread_1", classification: "PROMO", relevance_score: 7, thread_intent: "venting" },
-  { id: "thread_2", classification: "SKIP", relevance_score: 1, thread_intent: "venting" },
-  { id: "thread_3", classification: "PROMO", relevance_score: 9, thread_intent: "seeking_help" }
-].to_json
-
-rewritten_adapter = RubyLLM::Contract::Adapters::Test.new(response: rewritten_ids_response)
-result = ClassifyThreads.run(sample_threads, context: { adapter: rewritten_adapter })
-
-puts "=== REWRITTEN IDs (legacy code would silently fallback to positional matching) ==="
-puts "Status: #{result.status}"
-puts "Validation errors: #{result.validation_errors}"

data/examples/02_generate_comment.rb

@@ -1,203 +0,0 @@
-# frozen_string_literal: true
-
-# =============================================================================
-# EXAMPLE 2: Promo Comment Generation
-#
-# Real-world case: Generate a Reddit comment that subtly promotes a product.
-# The comment must match the thread's language, sound like a real user,
-# include a product link naturally, and follow strict persona rules.
-# =============================================================================
-
-require_relative "../lib/ruby_llm/contract"
-
-# =============================================================================
-# BEFORE: Legacy approach (200+ lines across multiple concerns)
-# =============================================================================
-#
-# In the legacy codebase, the prompt is assembled from 6+ helper methods
-# across comment_prompts.rb (240 lines):
-#
-# ```ruby
-# # System message built from 8 sections:
-# def system_message_for_promo
-#   base_system_message(
-#     intro: "You write Reddit comments that subtly promote a product...",
-#     voice_lines: [
-#       "Sound like a genuine user who found something useful, not an ad.",
-#       'Never say "I built" or "I made this".',
-#       "Sound like a real Reddit user: casual, no marketing speak...",
-#       # ... 10 more rules
-#     ],
-#     self_contained_lines: [...],
-#     extra_sections: [section("PROMO LINKING BASICS", [...])]
-#   )
-# end
-#
-# # User prompt built by string concatenation:
-# def build_promo_prompt(items, strict_language: false, comment_plan: nil)
-#   [
-#     <<~PRODUCT.strip,
-#     [PRODUCT]
-#     Domain: #{@url}
-#     PRODUCT
-#     pages_section,
-#     section("URL SELECTION", promo_url_selection_rules),
-#     section("PRODUCT MENTION", promo_product_mention_rules + [...]),
-#     comment_plan_section,
-#     comment_plan_rules,
-#     strict_lang_section,
-#     <<~ITEMS.strip
-#       [ITEMS]
-#       #{items.to_json}
-#     ITEMS
-#   ].compact.join("\n\n")
-# end
-# ```
-#
-# PROBLEMS:
-# - 200+ lines of string building spread across 8+ methods
-# - No validation on output — wrong language silently passes, caught later
-# - Persona + voice + rules mixed with data (URL, pages, items)
-# - Change one voice rule → no way to measure impact on output quality
-# - The `.compact.join("\n\n")` pattern is fragile — easy to break structure
-
-# =============================================================================
-# AFTER: ruby_llm-contract approach
-# =============================================================================
-
-PERSONA = <<~PERSONA.strip
-  You are a woman, 40+, a maker. You solve your own problems by building \
-  software. Outside of code you crochet, sew, 3D-print, and do \
-  astrophotography with your son. You hunt deals both offline and online. \
-  Your writing style: reflective, inventive, casual. You make typos, skip \
-  Polish diacritics sometimes, write like a real person on a forum.
-PERSONA
-
-class GeneratePromoComment < RubyLLM::Contract::Step::Base
-  input_type RubyLLM::Contract::Types::Hash.schema(
-    thread_title: RubyLLM::Contract::Types::String,
-    thread_selftext: RubyLLM::Contract::Types::String,
-    subreddit: RubyLLM::Contract::Types::String,
-    target_length: RubyLLM::Contract::Types::Integer,
-    thread_language: RubyLLM::Contract::Types::String,
-    product_url: RubyLLM::Contract::Types::String,
-    matched_page_url: RubyLLM::Contract::Types::String
-  )
-  output_type Hash
-
-  prompt do
-    system "You write Reddit comments that subtly promote a product. Return valid JSON only."
-
-    section "PERSONA", PERSONA
-
-    rule "Sound like a genuine user who found something useful, not an ad."
-    rule 'Never say "I built" or "I made this".'
-    rule "Casual tone, no marketing speak, no emojis, no bullet points."
-    rule "Pick one specific angle and share it concretely."
-    rule "Be opinionated; say what worked for you, not generic balanced advice."
-    rule 'NEVER start with "Nice X", "Cool X", "Love this". Jump straight into your point.'
-    rule "Give 2-3 options; the product link should be ONE of them, not the whole point."
-    rule "The comment must stand without the link."
-    rule 'Do not introduce the link with "PS:", "btw:", or parenthetical asides.'
-    rule "No markdown headers or formatting. Plain text only."
-    rule "Write in {thread_language}."
-    rule "Approximately {target_length} characters (±20%)."
-
-    section "PRODUCT", "Domain: {product_url}\nPage: {matched_page_url}"
-
-    user "r/{subreddit}: {thread_title}\n\n{thread_selftext}\n\nWrite a helpful comment."
-  end
-
-  validate("comment must not be empty") do |o|
-    o[:comment].is_a?(String) && o[:comment].strip.length > 10
-  end
-
-  validate("no markdown headers") do |o|
-    !o[:comment].to_s.match?(/^\#{2,}\s/)
-  end
-
-  validate("no emojis") do |o|
-    !o[:comment].to_s.match?(/[\u{1F600}-\u{1F64F}\u{1F300}-\u{1F5FF}\u{1F680}-\u{1F6FF}]/)
-  end
-
-  validate("includes product link") do |o, input|
-    o[:comment].to_s.include?(input[:matched_page_url])
-  end
-
-  validate("length within ±30% of target") do |o, input|
-    len = o[:comment].to_s.length
-    target = input[:target_length]
-    len.between?((target * 0.7).to_i, (target * 1.3).to_i)
-  end
-
-  validate("does not start with banned openings") do |o|
-    banned = ["Nice ", "Cool ", "Love this", "Great ", "Totally agree"]
-    banned.none? { |b| o[:comment].to_s.start_with?(b) }
-  end
-end
-
-# =============================================================================
-# DEMO: Run with test adapter
-# =============================================================================
-
-input = {
-  thread_title: "spent way too much on yarn this month lol",
-  thread_selftext: "Between Drops and the new Scheepjes line I'm broke. Anyone else track their spending?",
-  subreddit: "crochet",
-  target_length: 200,
-  thread_language: "en",
-  product_url: "https://deals.example.com",
-  matched_page_url: "https://deals.example.com/yarn-deals"
-}
-
-# Happy path — good comment
-good_comment = {
-  comment: "Ugh same. I started tracking last year and the numbers were brutal. " \
-           "What helped — monthly yarn budget plus checking https://deals.example.com/yarn-deals " \
-           "before impulse buying. Ravelry destash groups too."
-}.to_json
-
-adapter = RubyLLM::Contract::Adapters::Test.new(response: good_comment)
-result = GeneratePromoComment.run(input, context: { adapter: adapter })
-
-puts "=== HAPPY PATH ==="
-puts "Status: #{result.status}"
-puts "Comment: #{result.parsed_output[:comment]}"
-puts "Validation errors: #{result.validation_errors}"
-puts
-
-# Bad path — starts with banned opening
-bad_comment = {
-  comment: "Nice question! I track my yarn spending with a spreadsheet and also check " \
-           "https://deals.example.com/yarn-deals for sales."
-}.to_json
-
-bad_adapter = RubyLLM::Contract::Adapters::Test.new(response: bad_comment)
-result = GeneratePromoComment.run(input, context: { adapter: bad_adapter })
-
-puts "=== BANNED OPENING ==="
-puts "Status: #{result.status}"
-puts "Validation errors: #{result.validation_errors}"
-puts
-
-# Bad path — missing product link
-no_link_comment = {
-  comment: "Same here. I started a spreadsheet and realized I spent way more than I thought. " \
-           "Ravelry destash groups are great for cheap yarn though."
-}.to_json
-
-no_link_adapter = RubyLLM::Contract::Adapters::Test.new(response: no_link_comment)
-result = GeneratePromoComment.run(input, context: { adapter: no_link_adapter })
-
-puts "=== MISSING LINK ==="
-puts "Status: #{result.status}"
-puts "Validation errors: #{result.validation_errors}"
-puts
-
-# Inspect the rendered prompt AST
-puts "=== RENDERED PROMPT (first 3 messages) ==="
-adapter = RubyLLM::Contract::Adapters::Test.new(response: good_comment)
-result = GeneratePromoComment.run(input, context: { adapter: adapter })
-result.trace[:messages].first(3).each do |msg|
-  puts "  [#{msg[:role]}] #{msg[:content][0..80]}..."
-end