rails_console_ai 0.32.0 → 0.33.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7eab1fd8d3a5c8c7a228206f0c723bfa845fa2d344471e0251659658c0c5e571
-  data.tar.gz: c607b6cfa9e6834612513f0c75dc1303386f79bcdd96bba203a4fb5d0549f32b
+  metadata.gz: 8af25f720aae1fe703b947bdc860dcace9a13e2e1db61d9d698634fa46838e59
+  data.tar.gz: efc3b4c00ea66d941e5fb03c61543398fed5ffdde700c44c080ee5e8c8e09ad6
 SHA512:
-  metadata.gz: 1acd49dcf3370eaab8a8fb8ef77c7dad4746fcb0e0eb2f78935b53c870228a9b53a2cef8dc82608ed94f5f2642de905070fe9e241e9a98d8f408653535ce30d7
-  data.tar.gz: bd7ec6fcf50788b45f47f6a7b1948a74fb83cf4ff7fba62687eb2d6e8c75743972f4e83525d87f57096c1a6cd114611a69c5b6e2299a88dea6b02063cdf09adc
+  metadata.gz: 0b8de788b6391a303815cd160fb57ce4300c33dfd3f66645ce31f9bb256de0922b7ce8d26fd05c23dc8802c80da6201ffb9935c89cfd82b94ebde609b1631733
+  data.tar.gz: 5c73d678909c5e950cff5191b506a72570c2eb50bd2d6f01602bfe63ec2fade56c94b88d91f6d487803b073abd7b3565c9b92c355f90f7e32be82e465b72b7f9

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.33.0]
+
+- Support Claude Opus 5 and make it the default model for the Anthropic and Bedrock providers
+- Add runaway-loop circuit breakers to the tool loop — break when the same error signature repeats (warn at 3 occurrences, stop at 5) or when a token budget is exceeded (nudge at 500K input tokens, force a final answer at 1M), with a tailored wrap-up prompt for each break reason
+- Fail fast on known environment errors: a built-in hint recognizes decryption key misconfiguration (`bad decrypt` / `ActiveRecord::Encryption`) and tells the model not to retry, and apps can register their own hints via `config.error_hints`
+
 ## [0.32.0]
 
 - Switch default models to Claude Sonnet 5 and Opus 4.8, and rework pricing to match models by family so dated snapshots and Bedrock IDs are covered

data/README.md

@@ -291,7 +291,7 @@ RailsConsoleAi.configure do |config|
 end
 ```
 
-Default model: `claude-sonnet-5`. Thinking model: `claude-opus-4-8`. Prompt caching is enabled automatically.
+Default model: `claude-sonnet-5`. Thinking model: `claude-opus-5`. Prompt caching is enabled automatically.
 
 ### OpenAI
 
@@ -318,7 +318,7 @@ RailsConsoleAi.configure do |config|
   config.provider = :bedrock
   config.bedrock_region = 'us-east-1'
   # config.model = 'us.anthropic.claude-sonnet-5'        # default
-  # config.thinking_model = 'us.anthropic.claude-opus-4-8' # default
+  # config.thinking_model = 'us.anthropic.claude-opus-5'   # default
 end
 ```
 
@@ -396,9 +396,48 @@ RailsConsoleAi.configure do |config|
   config.timeout = 30                 # HTTP timeout in seconds
   config.max_tool_rounds = 200        # safety cap on tool-use loops
   config.code_search_paths = %w[app]  # directories for list_files / search_code
+
+  # Runaway-loop circuit breakers (see "Runaway sessions" below)
+  config.token_nudge_threshold = 500_000    # input tokens in one tool loop → nudge model to wrap up (nil disables)
+  config.token_stop_threshold  = 1_000_000  # input tokens in one tool loop → force a final answer (nil disables)
 end
 ```
 
+### Runaway sessions & known-issue hints
+
+Two mechanisms stop the LLM from burning tokens on a dead end:
+
+**Known-issue hints** — when executed code fails (or prints a rescued error) matching a
+known environment-level problem, the tool result includes explicit guidance telling the
+model not to retry. The built-in hint recognizes decryption failures
+(`OpenSSL::Cipher::CipherError` / "bad decrypt" / `ActiveRecord::Encryption` errors),
+which indicate a missing or placeholder encryption key in the console process — an
+environment issue no amount of retrying can fix. Repeat occurrences escalate the message.
+Apps can add their own:
+
+```ruby
+RailsConsoleAi.configure do |config|
+  config.error_hints << {
+    name: :vpn_required,
+    pattern: /Errno::ECONNREFUSED.*10\.8\./,
+    hint: "This host is only reachable over the VPN, which this console does not have. " \
+          "Do not retry; report the limitation to the user."
+  }
+end
+```
+
+**Circuit breakers** — inside a single tool loop, the engine tracks:
+
+- *Identical tool calls* (same tool + same args): warns at 3, breaks at 5.
+- *Repeated error signatures* (same normalized error from **different** code): warns at 3,
+  breaks at 5. This catches "new code, same dead end" loops that identical-call detection
+  misses. Digits are normalized so varying record IDs don't disguise the same failure.
+- *Token budget*: at `token_nudge_threshold` cumulative input tokens the model is told to
+  wrap up; at `token_stop_threshold` the loop is stopped and a final answer is forced.
+
+When any breaker trips, the model is asked to summarize what it established, what it
+could not determine and why, and what a human should do next — instead of iterating.
+
 ### Code Search Paths
 
 By default, `list_files` and `search_code` only look in `app/`. If your project has code in other directories (e.g. a frontend in `public/portal`, or shared code in `lib`), add them:

data/lib/rails_console_ai/configuration.rb

@@ -13,6 +13,7 @@ module RailsConsoleAi
     # (removed on opus-4-7+, sonnet-5, and fable-5).
     MODEL_FAMILIES = {
       'claude-fable-5'    => { input: 10.0, output: 50.0, max_tokens: 16_000, temperature: false },
+      'claude-opus-5'     => { input: 5.0,  output: 25.0, max_tokens: 16_000, temperature: false },
       'claude-opus-4-8'   => { input: 5.0,  output: 25.0, max_tokens: 16_000, temperature: false },
       'claude-opus-4-7'   => { input: 5.0,  output: 25.0, max_tokens: 16_000, temperature: false },
       'claude-opus-4-6'   => { input: 5.0,  output: 25.0, max_tokens: 16_000, temperature: true },
@@ -47,9 +48,30 @@ module RailsConsoleAi
       }
     end
 
+    # Known environment-level failures the executor recognizes and explains to the
+    # LLM on the FIRST occurrence, so it doesn't burn rounds rediscovering them
+    # through trial and error. Each entry: { name:, pattern:, hint: }.
+    # The pattern is matched against the execution error AND the captured output
+    # (to catch errors rescued and printed by the generated code itself).
+    DEFAULT_ERROR_HINTS = [
+      {
+        name: :decryption_failure,
+        pattern: /OpenSSL::Cipher::CipherError|bad decrypt|ActiveRecord::Encryption::Errors/i,
+        hint: "Decryption failed — this console process's encryption key (e.g. ENV['ENCRYPTION_KEY']) " \
+              "appears to be missing, invalid, or a placeholder for the data you are reading. This is an " \
+              "environment configuration issue, not a data issue, and it affects EVERY encrypted field in " \
+              "this session. Retrying with different code (reloading records, toggling encryption flags, " \
+              "decrypting other fields or records) will fail the same way. Do NOT retry. Report this " \
+              "limitation to the user, tell them the encryption key needs to be configured for this " \
+              "environment, and answer using only what you can determine without decrypting."
+      }
+    ].freeze
+
     attr_accessor :provider, :api_key, :model, :thinking_model, :max_tokens,
                   :auto_execute, :temperature,
                   :timeout, :debug, :max_tool_rounds,
+                  :error_hints,
+                  :token_nudge_threshold, :token_stop_threshold,
                   :storage_adapter, :memories_enabled,
                   :session_logging, :connection_class,
                   :admin_username, :admin_password,
@@ -75,6 +97,9 @@ module RailsConsoleAi
       @timeout      = 30
       @debug        = false
       @max_tool_rounds = 200
+      @error_hints = DEFAULT_ERROR_HINTS.dup
+      @token_nudge_threshold = 500_000    # input tokens in one tool loop → nudge model to wrap up (nil disables)
+      @token_stop_threshold  = 1_000_000  # input tokens in one tool loop → force a final answer (nil disables)
       @storage_adapter  = nil
       @memories_enabled = true
       @session_logging  = true
@@ -222,13 +247,13 @@ module RailsConsoleAi
 
       case @provider
       when :anthropic
-        'claude-opus-4-8'
+        'claude-opus-5'
       when :openai
         'gpt-5.3-codex'
       when :local
         @local_model
       when :bedrock
-        'us.anthropic.claude-opus-4-8'
+        'us.anthropic.claude-opus-5'
       end
     end
 

data/lib/rails_console_ai/conversation_engine.rb

@@ -7,6 +7,8 @@ module RailsConsoleAi
     LARGE_OUTPUT_PREVIEW_CHARS = 16_000  # chars — how much of the output the LLM sees upfront
     LOOP_WARN_THRESHOLD = 3              # same tool+args repeated → inject warning
     LOOP_BREAK_THRESHOLD = 5             # same tool+args repeated → break loop
+    REPEAT_ERROR_WARN_THRESHOLD = 3      # same error signature (any args) → inject warning
+    REPEAT_ERROR_BREAK_THRESHOLD = 5     # same error signature (any args) → force wrap-up
 
     def initialize(binding_context:, channel:, slack_thread_ts: nil, slack_channel_name: nil)
       @binding_context = binding_context
@@ -46,6 +48,7 @@ module RailsConsoleAi
         if executed && @executor.last_error && !@executor.last_safety_error
           error_msg = "Code execution failed with error: #{@executor.last_error}"
           error_msg = error_msg[0..1000] + '...' if error_msg.length > 1000
+          error_msg += "\n\n#{@executor.last_error_hint}" if @executor.last_error_hint
           conversation << { role: :assistant, content: @_last_result_text }
           conversation << { role: :user, content: error_msg }
 
@@ -347,6 +350,7 @@ module RailsConsoleAi
       elsif @executor.last_error
         error_msg = "Code execution failed with error: #{@executor.last_error}"
         error_msg = error_msg[0..1000] + '...' if error_msg.length > 1000
+        error_msg += "\n\n#{@executor.last_error_hint}" if @executor.last_error_hint
         @history << { role: :user, content: error_msg }
         :error
       else
@@ -796,7 +800,11 @@ module RailsConsoleAi
       last_tool_names = []
 
       exhausted = false
+      wrap_up_reason = nil
       tool_call_counts = Hash.new(0)
+      error_sig_counts = Hash.new(0)
+      warned_error_sigs = Set.new
+      token_nudge_sent = false
 
       max_rounds.times do |round|
         if @channel.cancelled?
@@ -918,6 +926,12 @@ module RailsConsoleAi
             $stderr.puts "\e[35m[debug] tool result (#{tool_result.to_s.length} chars)\e[0m"
           end
 
+          # Track repeated error signatures across DIFFERENT tool calls — the
+          # identical-call loop detection below misses "same dead end, new code".
+          if (sig = error_signature(tool_result))
+            error_sig_counts[sig] += 1
+          end
+
           tool_msg = provider.format_tool_result(tc[:id], tool_result)
           full_text = tool_result.to_s
           output_id = @executor.store_output(full_text)
@@ -942,23 +956,68 @@ module RailsConsoleAi
           if tool_call_counts[key] >= LOOP_BREAK_THRESHOLD
             @channel.display_status("  Loop detected: #{tc[:name]} called #{tool_call_counts[key]} times with same args — stopping.")
             exhausted = true
+            wrap_up_reason ||= :tool_loop
           elsif tool_call_counts[key] >= LOOP_WARN_THRESHOLD
             @channel.display_status("  Warning: #{tc[:name]} called #{tool_call_counts[key]} times with same args — consider a different approach.")
             messages << { role: :user, content: "You are repeating the same tool call (#{tc[:name]}) with the same arguments. This is not making progress. Try a different approach or provide your answer now." }
           end
         end
+
+        # Circuit breaker: the same error signature recurring across different
+        # tool calls means no new information is being gained (e.g. every
+        # decryption attempt failing with "bad decrypt" regardless of the code).
+        error_sig_counts.each do |sig, count|
+          if count >= REPEAT_ERROR_BREAK_THRESHOLD
+            @channel.display_status("  Circuit breaker: same error hit #{count} times (#{sig}) — stopping.")
+            exhausted = true
+            wrap_up_reason ||= :repeated_errors
+          elsif count >= REPEAT_ERROR_WARN_THRESHOLD && !warned_error_sigs.include?(sig)
+            warned_error_sigs << sig
+            @channel.display_status("  Warning: same error hit #{count} times — nudging model to change strategy.")
+            messages << { role: :user, content: "You have now hit the same error #{count} times (#{sig}). Trying variations of the same approach is not producing new information. If this error cannot be resolved from this session, stop investigating it: summarize what you have established, state what you could not determine and why, and give the user your best answer." }
+          end
+        end
+
+        # Circuit breaker: token budget for a single tool loop.
+        config = RailsConsoleAi.configuration
+        if config.token_stop_threshold && total_input >= config.token_stop_threshold
+          @channel.display_status("  Token budget exceeded (#{format_tokens(total_input)} input tokens this request) — forcing wrap-up.")
+          exhausted = true
+          wrap_up_reason ||= :token_budget
+        elsif config.token_nudge_threshold && total_input >= config.token_nudge_threshold && !token_nudge_sent
+          token_nudge_sent = true
+          @channel.display_status("  High token usage (#{format_tokens(total_input)} input tokens this request) — nudging model to wrap up.")
+          messages << { role: :user, content: "This investigation has consumed #{format_tokens(total_input)} input tokens without reaching a conclusion. Wrap up now: stop opening new lines of investigation, summarize what you have established, state what you could not determine and why, and give the user your best answer. Only make another tool call if you are confident a single call will resolve the question." }
+        end
+
         break if exhausted
 
         # If the user declined execution, don't call the LLM again —
         # just return to the prompt so they can correct their request.
         break if @executor.last_cancelled?
 
-        exhausted = true if round == max_rounds - 1
+        if round == max_rounds - 1
+          exhausted = true
+          wrap_up_reason ||= :round_cap
+        end
       end
 
       if exhausted
-        $stdout.puts "\e[33m  Hit tool round limit (#{max_rounds}). Forcing final answer. Increase with: RailsConsoleAi.configure { |c| c.max_tool_rounds = 200 }\e[0m"
-        messages << { role: :user, content: "You've used all available tool rounds. Please provide your best answer now based on what you've learned so far." }
+        final_nudge =
+          case wrap_up_reason
+          when :repeated_errors
+            "You have hit the same error repeatedly without gaining new information. Do not attempt any further tool calls. Give the user a final answer now: (1) what you established, (2) what you could not determine and the blocking error, and (3) what a human should do next."
+          when :token_budget
+            "This session has exceeded its token budget. Do not attempt any further tool calls. Give the user a final answer now: (1) what you established, (2) what you could not determine and why, and (3) what a human should do next."
+          when :tool_loop
+            "You kept repeating the same tool call with the same arguments. Do not attempt any further tool calls. Provide your best answer now based on what you've learned so far."
+          else
+            "You've used all available tool rounds. Please provide your best answer now based on what you've learned so far."
+          end
+        if wrap_up_reason.nil? || wrap_up_reason == :round_cap
+          $stdout.puts "\e[33m  Hit tool round limit (#{max_rounds}). Forcing final answer. Increase with: RailsConsoleAi.configure { |c| c.max_tool_rounds = 200 }\e[0m"
+        end
+        messages << { role: :user, content: final_nudge }
         result = provider.chat(messages, system_prompt: active_system_prompt)
         total_input += result.input_tokens || 0
         total_output += result.output_tokens || 0
@@ -1167,6 +1226,15 @@ module RailsConsoleAi
       str.length > max ? str[0..max] + '...' : str
     end
 
+    # Extract a normalized error signature from a tool result so we can detect
+    # "same failure, different code" loops. Digits are collapsed so record IDs,
+    # counts, and offsets don't make identical failures look distinct.
+    def error_signature(tool_result)
+      line = tool_result.to_s[/^ERROR: [^\n]+/]
+      return nil unless line
+      line.gsub(/\d+/, 'N')[0, 160]
+    end
+
     # Wraps mid-task user messages with explicit framing so the model treats them
     # as a real-time interruption that supersedes the prior task, rather than as
     # a reply to the most recent tool result.

data/lib/rails_console_ai/executor.rb

@@ -44,7 +44,8 @@ module RailsConsoleAi
   class Executor
     CODE_REGEX = /```ruby\s*\n(.*?)```/m
 
-    attr_reader :binding_context, :last_error, :last_safety_error, :last_safety_exception
+    attr_reader :binding_context, :last_error, :last_safety_error, :last_safety_exception,
+                :last_error_hint
     attr_accessor :on_prompt
 
     def initialize(binding_context, channel: nil)
@@ -55,6 +56,7 @@ module RailsConsoleAi
       @output_store = {}
       @output_counter = 0
       @active_skill_bypass_methods = Set.new
+      @error_hint_counts = Hash.new(0)
     end
 
     def extract_code(response)
@@ -98,6 +100,7 @@ module RailsConsoleAi
       @last_error = nil
       @last_safety_error = false
       @last_safety_exception = nil
+      @last_error_hint = nil
       captured_output = StringIO.new
       old_stdout = $stdout
       # Three capture strategies:
@@ -140,6 +143,8 @@ module RailsConsoleAi
       display_result(result) if display
 
       @last_output = captured_output.string
+      # Code may have rescued a known failure and printed it — still surface the hint.
+      @last_error_hint = build_error_hint(@last_output)
       result
     rescue Interrupt
       restore_stdout(use_thread_local, old_stdout)
@@ -174,6 +179,7 @@ module RailsConsoleAi
         return nil
       end
       @last_error = "#{e.class}: #{e.message}"
+      @last_error_hint = build_error_hint(@last_error, captured_output&.string)
       backtrace = e.backtrace.first(3).map { |line| "  #{line}" }.join("\n")
       log_execution_error("Error: #{@last_error}\n#{backtrace}")
       @last_output = captured_output&.string
@@ -346,6 +352,29 @@ module RailsConsoleAi
 
     private
 
+    # Match the error/output against configured known-issue patterns
+    # (Configuration#error_hints). Returns a guidance string for the LLM, or nil.
+    # The first occurrence explains the issue; repeats escalate so the model
+    # stops probing the same dead end.
+    def build_error_hint(*texts)
+      text = texts.compact.join("\n")
+      return nil if text.strip.empty?
+
+      hint_def = Array(RailsConsoleAi.configuration.error_hints).find do |h|
+        h[:pattern] && text.match?(h[:pattern])
+      end
+      return nil unless hint_def
+
+      count = (@error_hint_counts[hint_def[:name]] += 1)
+      if count == 1
+        "KNOWN ISSUE DETECTED (#{hint_def[:name]}): #{hint_def[:hint]}"
+      else
+        "KNOWN ISSUE (#{hint_def[:name]}) — this is failure ##{count} for the same underlying problem. " \
+        "You were already told this cannot succeed from this session. Stop retrying now and report the " \
+        "limitation to the user. Reminder: #{hint_def[:hint]}"
+      end
+    end
+
     def restore_stdout(use_thread_local, old_stdout)
       if use_thread_local
         Thread.current[:capture_io] = nil

data/lib/rails_console_ai/tools/registry.rb

@@ -698,13 +698,16 @@ module RailsConsoleAi
         end
 
         if @executor.last_error
-          return "ERROR: #{@executor.last_error}"
+          result = "ERROR: #{@executor.last_error}"
+          result += "\n\n#{@executor.last_error_hint}" if @executor.last_error_hint
+          return result
         end
 
         output = @executor.last_output
         parts = []
         parts << "Output:\n#{output.strip}" if output && !output.strip.empty?
         parts << "Return value: #{exec_result.inspect}"
+        parts << @executor.last_error_hint if @executor.last_error_hint
         parts.join("\n\n")
       end
 
@@ -808,6 +811,7 @@ module RailsConsoleAi
           step_report = "Step #{i + 1} (#{step['description']}):\n"
           if error
             step_report += "ERROR: #{error}\n"
+            step_report += "#{@executor.last_error_hint}\n" if @executor.last_error_hint
           end
           if output && !output.strip.empty?
             step_report += "Output: #{output.strip}\n"

data/lib/rails_console_ai/version.rb

@@ -1,3 +1,3 @@
 module RailsConsoleAi
-  VERSION = '0.32.0'.freeze
+  VERSION = '0.33.0'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_console_ai
 version: !ruby/object:Gem::Version
-  version: 0.32.0
+  version: 0.33.0
 platform: ruby
 authors:
 - Cortfr