rails_console_ai 0.34.0 → 0.35.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61fcabfed3f03e58e104b7c8b49b86ccf365db5dbae5e1dbf1f8f1b7e63d811c
-  data.tar.gz: ec844ca4e1251fb9c1f0c0172095050745ef9690a90defefbcded92eae0962f8
+  metadata.gz: 37ef99b1cc4572e89283e5210b15e6110bac2b0adc758a1b7d222c603c4557c2
+  data.tar.gz: 511f76003fdc00ce0104b506eaa71d7de918e3cf1f62eebd395308461caeefd1
 SHA512:
-  metadata.gz: f2294a51714714de69afcc908dccbcb8d5034999973c40b4533600579e8617efc1133ed918ed7925aa082a3afd5598335b5a09527d1a933b38a6ddbf8143d595
-  data.tar.gz: bce68674c9467a92eac6b7521e4f1e39f1d06c32b374f38f627513c7ab31bdda57a12a2e937654103a2322d075b594aa56b610cf2ad716f1965f1c2d6123cfad
+  metadata.gz: e6cb2ccc4f03fbcafff6d7edcace1c80fd76a99692404f7e05aa039e9276665b07e03ab70b12043635b37742c5e05ffe1fa9fd42f77e25de6daff329c90e0dfc
+  data.tar.gz: ee6acd8f33f2d13c921832fd1d4470e9d08bd8a795ec45d7ebb3c7b67ae7ca3fb6475b46796192dcd4a0b2a48d66b0bbb8bc2b2e47e498e9785c12dad7eefba4

data/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.35.0]
+
+- Extend prompt caching to the full conversation history
+- Add an option for a one-hour prompt cache
+- Fix cost reporting to price cached reads and writes correctly
+- Correct the Claude Sonnet 5 pricing rate
+- Add separate connect and read timeouts for provider requests
+- Retry transient provider failures with exponential backoff
+- Warn when a conversation approaches the model's context window
+- Stop overriding a configured request timeout
+- Fix a failure when a turn hits the tool round limit
+
 ## [0.34.0]
 
 - Add an `:in_process_requests` built-in safety guard that blocks in-process HTTP dispatch against the app itself — `ActionDispatch::Integration::Session` requests (the console `app` helper) and direct Rack dispatch (`Rails.application.call`) — for all verbs including GET, since these can hang the session thread indefinitely; allowlist entries are request paths

data/app/helpers/rails_console_ai/sessions_helper.rb

@@ -1,10 +1,17 @@
 module RailsConsoleAi
   module SessionsHelper
+    # All four usage buckets bill at their own rate. `input_tokens` is the uncached
+    # remainder only — on a cached session it is a tiny fraction of the prompt, so
+    # pricing input+output alone reads as near-zero for the sessions that actually
+    # cost the most.
     def estimated_cost(session)
       pricing = Configuration.pricing_for(session.model)
       return nil unless pricing
 
-      (session.input_tokens * pricing[:input]) + (session.output_tokens * pricing[:output])
+      (session.input_tokens * pricing[:input]) +
+        (session.output_tokens * pricing[:output]) +
+        (session.try(:cache_read_tokens).to_i * pricing[:cache_read]) +
+        (session.try(:cache_write_tokens).to_i * pricing[:cache_write])
     end
 
     def format_cost(session)

data/app/views/rails_console_ai/sessions/index.html.erb

@@ -33,7 +33,7 @@
           <td class="query-cell"><a href="<%= rails_console_ai.session_path(session) %>" title="<%= h session.query.truncate(200) %>"><%= truncate(session.query.gsub(/\s+/, ' ').strip, length: 80) %></a></td>
           <td><span class="badge badge-<%= session.mode %>"><%= session.mode %></span></td>
           <td><% status = session.try(:status) %><%= status.present? ? content_tag(:span, status, class: "badge badge-status-#{status}") : '-' %></td>
-          <td class="mono"><%= session.input_tokens + session.output_tokens %></td>
+          <td class="mono"><%= session.input_tokens + session.output_tokens + session.try(:cache_read_tokens).to_i + session.try(:cache_write_tokens).to_i %></td>
           <td class="mono"><%= format_cost(session) %></td>
           <td class="mono"><%= session.duration_ms ? "#{session.duration_ms}ms" : '-' %></td>
         </tr>

data/app/views/rails_console_ai/sessions/show.html.erb

@@ -44,6 +44,12 @@
       <label>Tokens (in / out)</label>
       <span class="mono"><%= @session.input_tokens %> / <%= @session.output_tokens %></span>
     </div>
+    <% if (@session.try(:cache_read_tokens).to_i + @session.try(:cache_write_tokens).to_i) > 0 %>
+      <div class="meta-item">
+        <label>Cache (read / write)</label>
+        <span class="mono"><%= @session.cache_read_tokens %> / <%= @session.cache_write_tokens %></span>
+      </div>
+    <% end %>
     <div class="meta-item">
       <label>Est. Cost</label>
       <span class="mono"><%= format_cost(@session) %></span>

data/lib/generators/rails_console_ai/templates/initializer.rb

@@ -20,8 +20,11 @@ RailsConsoleAi.configure do |config|
   # Max tool-use rounds per query (safety cap)
   config.max_tool_rounds = 10
 
-  # HTTP timeout in seconds
-  config.timeout = 30
+  # Read timeout in seconds for one provider request. The default (300) allows for
+  # a long thinking turn; a value too low cuts off generation mid-stream, which
+  # loses the turn and the tokens already spent on it. The connect timeout is
+  # separate (config.open_timeout, default 10).
+  # config.timeout = 300
 
   # Local model provider (Ollama, vLLM, or any OpenAI-compatible server):
   # config.provider = :local

data/lib/rails_console_ai/configuration.rb

@@ -11,17 +11,23 @@ module RailsConsoleAi
     # Cache pricing is derived: read = 0.1x input, write = 1.25x input.
     # temperature: false marks families that reject the `temperature` parameter
     # (removed on opus-4-7+, sonnet-5, and fable-5).
+    # max_tokens is the OUTPUT cap we request; context is the total window.
     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 },
-      'claude-sonnet-5'   => { input: 3.0,  output: 15.0, max_tokens: 16_000, temperature: false },
-      'claude-sonnet-4-6' => { input: 3.0,  output: 15.0, max_tokens: 16_000, temperature: true },
-      'claude-haiku-4-5'  => { input: 1.0,  output: 5.0,  max_tokens: 16_000, temperature: true },
+      'claude-fable-5'    => { input: 10.0, output: 50.0, max_tokens: 16_000, context: 1_000_000, temperature: false },
+      'claude-opus-5'     => { input: 5.0,  output: 25.0, max_tokens: 16_000, context: 1_000_000, temperature: false },
+      'claude-opus-4-8'   => { input: 5.0,  output: 25.0, max_tokens: 16_000, context: 1_000_000, temperature: false },
+      'claude-opus-4-7'   => { input: 5.0,  output: 25.0, max_tokens: 16_000, context: 1_000_000, temperature: false },
+      'claude-opus-4-6'   => { input: 5.0,  output: 25.0, max_tokens: 16_000, context: 1_000_000, temperature: true },
+      'claude-sonnet-5'   => { input: 2.0,  output: 10.0, max_tokens: 16_000, context: 1_000_000, temperature: false },
+      'claude-sonnet-4-6' => { input: 3.0,  output: 15.0, max_tokens: 16_000, context: 1_000_000, temperature: true },
+      'claude-haiku-4-5'  => { input: 1.0,  output: 5.0,  max_tokens: 16_000, context: 200_000,   temperature: true },
     }.freeze
 
+    # Assumed context window for models with no family entry — local models and
+    # anything newer than this table. Deliberately small: under-guessing warns a
+    # little early, over-guessing means no warning before the request is rejected.
+    DEFAULT_CONTEXT_WINDOW = 200_000
+
     # Family keys sorted longest-first so a more specific family always wins
     # if keys ever overlap (e.g. a future 'claude-sonnet-5-5' entry would match
     # before 'claude-sonnet-5').
@@ -36,7 +42,9 @@ module RailsConsoleAi
 
     # Per-token pricing for a model ID, matched by family. Returns
     # { input:, output:, cache_read:, cache_write: } or nil for unknown models.
-    def self.pricing_for(model_id)
+    # Cache reads bill at 0.1x the base input rate; cache writes at 1.25x for the
+    # 5-minute cache and 2x for the 1-hour cache.
+    def self.pricing_for(model_id, cache_ttl: nil)
       family = model_family(model_id)
       return nil unless family
       input = family[:input] / 1_000_000
@@ -44,10 +52,16 @@ module RailsConsoleAi
         input: input,
         output: family[:output] / 1_000_000,
         cache_read: input * 0.1,
-        cache_write: input * 1.25,
+        cache_write: input * (cache_ttl.to_s == '1h' ? 2.0 : 1.25),
       }
     end
 
+    # Total context window for a model ID, matched by family.
+    def self.context_window_for(model_id)
+      family = model_family(model_id)
+      (family && family[:context]) || DEFAULT_CONTEXT_WINDOW
+    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: }.
@@ -69,9 +83,10 @@ module RailsConsoleAi
 
     attr_accessor :provider, :api_key, :model, :thinking_model, :max_tokens,
                   :auto_execute, :temperature,
-                  :timeout, :debug, :max_tool_rounds,
+                  :timeout, :open_timeout, :max_retries, :debug, :max_tool_rounds,
                   :error_hints,
                   :token_nudge_threshold, :token_stop_threshold,
+                  :cache_ttl,
                   :storage_adapter, :memories_enabled,
                   :session_logging, :connection_class,
                   :admin_username, :admin_password,
@@ -94,12 +109,29 @@ module RailsConsoleAi
       @max_tokens   = nil
       @auto_execute = false
       @temperature  = 0.2
-      @timeout      = 30
+      # Read timeout for one provider request. Adaptive thinking plus a large output
+      # cap means a single agentic call can legitimately run for minutes; the old 30s
+      # cut those off mid-generation, which loses the turn and the tokens already
+      # spent on it, and sends the user back to re-ask from a cold cache.
+      @timeout      = 300
+      @open_timeout = 10    # establishing the connection, not generating the response
+      @max_retries  = 2     # transient failures only — see Providers::Base#with_retries
       @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)
+      # Measured against total prompt tokens sent in one tool loop — uncached input
+      # plus cache reads plus cache writes. Not the API's `input_tokens` alone:
+      # that is only the uncached remainder, so with caching on it stays near zero
+      # regardless of conversation size and neither guard would ever fire.
+      @token_nudge_threshold = 500_000    # prompt tokens in one tool loop → nudge model to wrap up (nil disables)
+      @token_stop_threshold  = 1_000_000  # prompt tokens in one tool loop → force a final answer (nil disables)
+      # Prompt cache lifetime: nil/'5m' for the 5-minute default, '1h' for the
+      # 1-hour cache. Within a tool loop, rounds are seconds apart and 5m is
+      # strictly cheaper (a read refreshes the entry, and the write costs 1.25x
+      # vs 2x). '1h' pays off when a human sits between turns for more than five
+      # minutes — long interactive console sessions and Slack threads — because
+      # a miss there resends the whole conversation at full price.
+      @cache_ttl = nil
       @storage_adapter  = nil
       @memories_enabled = true
       @session_logging  = true
@@ -245,6 +277,13 @@ module RailsConsoleAi
       @temperature
     end
 
+    # Returns '1h' when the 1-hour prompt cache is requested, else nil (the
+    # 5-minute default). Providers that offer only one cache duration ignore it.
+    def resolved_cache_ttl
+      return nil unless @cache_ttl
+      @cache_ttl.to_s == '1h' ? '1h' : nil
+    end
+
     def resolved_thinking_model
       return @thinking_model if @thinking_model && !@thinking_model.empty?
 

data/lib/rails_console_ai/conversation_engine.rb

@@ -1,6 +1,7 @@
 module RailsConsoleAi
   class ConversationEngine
     attr_reader :history, :total_input_tokens, :total_output_tokens,
+                :total_cache_read_tokens, :total_cache_write_tokens,
                 :interactive_session_id, :session_name
 
     LARGE_OUTPUT_THRESHOLD = 20_000      # chars — truncate tool results larger than this immediately
@@ -9,6 +10,7 @@ module RailsConsoleAi
     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
+    CONTEXT_WARN_FRACTION = 0.7          # share of the model's context window → suggest /compact
 
     def initialize(binding_context:, channel:, slack_thread_ts: nil, slack_channel_name: nil)
       @binding_context = binding_context
@@ -22,6 +24,8 @@ module RailsConsoleAi
       @history = []
       @total_input_tokens = 0
       @total_output_tokens = 0
+      @total_cache_read_tokens = 0
+      @total_cache_write_tokens = 0
       @token_usage = Hash.new { |h, k| h[k] = { input: 0, output: 0 } }
       @interactive_session_id = nil
       @session_name = nil
@@ -42,7 +46,7 @@ module RailsConsoleAi
       start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       console_capture = StringIO.new
       exec_result = with_console_capture(console_capture) do
-        conversation = [{ role: :user, content: query }]
+        conversation = [{ role: :user, content: user_turn(query) }]
         exec_result, code, executed = one_shot_round(conversation)
 
         if executed && @executor.last_error && !@executor.last_safety_error
@@ -85,7 +89,7 @@ module RailsConsoleAi
       start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       console_capture = StringIO.new
       with_console_capture(console_capture) do
-        result, _ = send_query(query)
+        result, _ = send_query(user_turn(query))
         track_usage(result)
         @executor.display_response(result.text)
         display_usage(result)
@@ -115,7 +119,7 @@ module RailsConsoleAi
       @channel.log_input(text) if @channel.respond_to?(:log_input)
       @interactive_query ||= text
       maybe_auto_upgrade_thinking(text)
-      @history << { role: :user, content: text }
+      @history << { role: :user, content: user_turn(text) }
 
       status = send_and_execute
       if status == :error
@@ -144,9 +148,6 @@ module RailsConsoleAi
       sys_prompt = init_system_prompt(existing_guide)
       messages = [{ role: :user, content: "Explore this Rails application and generate the application guide." }]
 
-      original_timeout = RailsConsoleAi.configuration.timeout
-      RailsConsoleAi.configuration.timeout = [original_timeout, 120].max
-
       result, _ = send_query_with_tools(messages, system_prompt: sys_prompt, tools_override: init_tools)
 
       guide_text = result.text.to_s.strip
@@ -172,8 +173,6 @@ module RailsConsoleAi
     rescue => e
       @channel.display_error("RailsConsoleAi Error: #{e.class}: #{e.message}")
       nil
-    ensure
-      RailsConsoleAi.configuration.timeout = original_timeout if original_timeout
     end
 
     # --- Interactive session management ---
@@ -184,6 +183,8 @@ module RailsConsoleAi
       @history = []
       @total_input_tokens = 0
       @total_output_tokens = 0
+      @total_cache_read_tokens = 0
+      @total_cache_write_tokens = 0
       @token_usage = Hash.new { |h, k| h[k] = { input: 0, output: 0 } }
       @interactive_query = nil
       @interactive_session_id = nil
@@ -203,20 +204,33 @@ module RailsConsoleAi
       @session_name = session.name
       @total_input_tokens = session.input_tokens || 0
       @total_output_tokens = session.output_tokens || 0
+      # respond_to? rather than #try: the columns are only present after
+      # RailsConsoleAi.migrate! has run, and this path must not depend on
+      # ActiveSupport being loaded.
+      @total_cache_read_tokens = session_column(session, :cache_read_tokens)
+      @total_cache_write_tokens = session_column(session, :cache_write_tokens)
       @prior_duration_ms = session.duration_ms || 0
 
       if session.model && (session.input_tokens.to_i > 0 || session.output_tokens.to_i > 0)
         @token_usage[session.model][:input] = session.input_tokens.to_i
         @token_usage[session.model][:output] = session.output_tokens.to_i
+        @token_usage[session.model][:cache_read] = @total_cache_read_tokens
+        @token_usage[session.model][:cache_write] = @total_cache_write_tokens
       end
     end
 
+    # Reads a column that may not exist yet on this install (added by migrate!).
+    def session_column(session, name)
+      return 0 unless session.respond_to?(name)
+      session.public_send(name).to_i
+    end
+
     def set_interactive_query(text)
       @interactive_query ||= text
     end
 
     def add_user_message(text)
-      @history << { role: :user, content: text }
+      @history << { role: :user, content: user_turn(text) }
     end
 
     def pop_last_message
@@ -413,21 +427,16 @@ module RailsConsoleAi
       $stdout.puts "\e[36m  Cost estimate:\e[0m"
 
       @token_usage.each do |model, usage|
-        pricing = Configuration.pricing_for(model)
+        pricing = Configuration.pricing_for(model, cache_ttl: RailsConsoleAi.configuration.resolved_cache_ttl)
         pricing ||= { input: 0.0, output: 0.0 } if RailsConsoleAi.configuration.provider == :local
         input_str = "in: #{format_tokens(usage[:input])}"
         output_str = "out: #{format_tokens(usage[:output])}"
 
         if pricing
-          cost = (usage[:input] * pricing[:input]) + (usage[:output] * pricing[:output])
           cache_read = usage[:cache_read] || 0
           cache_write = usage[:cache_write] || 0
-          if (cache_read > 0 || cache_write > 0) && pricing[:cache_read]
-            # Subtract cached tokens from full-price input, add at cache rates
-            cost -= cache_read * pricing[:input]
-            cost += cache_read * pricing[:cache_read]
-            cost += cache_write * (pricing[:cache_write] - pricing[:input])
-          end
+          cost = usage_cost(pricing, input: usage[:input], output: usage[:output],
+                                     cache_read: cache_read, cache_write: cache_write)
           total_cost += cost
           cache_str = ""
           cache_str = "  cache r: #{format_tokens(cache_read)} w: #{format_tokens(cache_write)}" if cache_read > 0 || cache_write > 0
@@ -466,15 +475,29 @@ module RailsConsoleAi
       conversation_messages(messages, **opts)
     end
 
+    # The system prompt must stay byte-identical for the life of a session: it
+    # renders ahead of the entire conversation, so any change to it invalidates
+    # the system cache AND every cached message after it. Everything here is
+    # fixed for the session — the binding's variable list, which changes whenever
+    # the console (or generated code) assigns a local, rides along with the user
+    # turn instead. See #user_turn.
     def context
       base = @context_base ||= context_builder.build
       parts = [base]
       parts << safety_context
       parts << @channel.system_instructions
-      parts << binding_variable_summary
       parts.compact.join("\n\n")
     end
 
+    # Composes a user turn with the console binding's current variables appended.
+    # This belongs in `messages`, not in the system prompt: a message at turn 5
+    # invalidates nothing before turn 5, and because it is persisted into history
+    # rather than injected per-request, the prefix stays append-only.
+    def user_turn(text)
+      summary = binding_variable_summary
+      summary ? "#{text}\n\n#{summary}" : text
+    end
+
     AUTO_THINK_PATTERN = /\bthink\s+(harder|deeper|hard|carefully|more\s+carefully)\b/i
 
     def maybe_auto_upgrade_thinking(text)
@@ -576,13 +599,27 @@ module RailsConsoleAi
       end
     end
 
+    # Warn when the conversation is closing in on the model's context window — the
+    # one thing a long conversation still costs. It used to warn at 50K characters
+    # (~12K tokens) on the theory that a big conversation is an expensive one; that
+    # was true when every round re-sent the whole history at full input price, but
+    # the history is cached now and a warm 15K-token prefix is unremarkable. Warning
+    # there just nags, and the advice actively costs money: /compact rewrites the
+    # prefix, throwing away the cache, and spends a summarization call doing it.
+    #
+    # So this fires on headroom instead, and says what compacting costs.
     def warn_if_history_large
-      chars = @history.sum { |m| m[:content].to_s.length }
+      return if @compact_warned
 
-      if chars > 50_000 && !@compact_warned
-        @compact_warned = true
-        $stdout.puts "\e[33m  Conversation is getting large (~#{format_tokens(chars)} chars). Consider running /compact to reduce context size.\e[0m"
-      end
+      tokens = estimate_request_tokens(@history)
+      window = Configuration.context_window_for(effective_model)
+      return if tokens < window * CONTEXT_WARN_FRACTION
+
+      @compact_warned = true
+      pct = ((tokens.to_f / window) * 100).round
+      $stdout.puts "\e[33m  Conversation is using ~#{format_tokens(tokens)} of the #{format_tokens(window)} " \
+                   "context window (~#{pct}%). /compact will summarize it to free room — it also resets the " \
+                   "prompt cache, so only run it when you need the headroom.\e[0m"
     end
 
     # --- Session logging ---
@@ -814,11 +851,33 @@ module RailsConsoleAi
       max_rounds = RailsConsoleAi.configuration.max_tool_rounds
       total_input = 0
       total_output = 0
+      # Cache activity has to be summed across rounds and reported out with the
+      # rest of the usage: it is the only evidence that caching is working, and
+      # `input_tokens` alone can't show it (the API reports only the UNCACHED
+      # remainder there — total prompt size is input + cache_read + cache_write).
+      total_cache_read = 0
+      total_cache_write = 0
+      # Prompt volume actually sent this loop. `total_input` alone is NOT it: the
+      # API reports only the uncached remainder there, so once caching is working
+      # it stays near zero no matter how large the conversation grows. The token
+      # budget below has to be measured against the full prompt or it never fires.
+      total_prompt = -> { total_input + total_cache_read + total_cache_write }
       result = nil
       new_messages = []
       last_thinking = nil
       last_tool_names = []
 
+      # Steering messages go into BOTH the request and the persisted history.
+      # Injecting a message for one request and dropping it from history rewrites
+      # the prefix the next turn sends, so every cached block from that point on
+      # misses — and the model also loses the fact that it was already nudged.
+      add_nudge = lambda do |text|
+        msg = { role: :user, content: text }
+        messages << msg
+        new_messages << msg
+        msg
+      end
+
       exhausted = false
       wrap_up_reason = nil
       tool_call_counts = Hash.new(0)
@@ -855,7 +914,7 @@ module RailsConsoleAi
 
         if round > 0
           req_tokens = estimate_request_tokens(messages)
-          @channel.display_status("  #{llm_status(round, messages, req_tokens, total_input, last_thinking, last_tool_names)}")
+          @channel.display_status("  #{llm_status(round, messages, req_tokens, total_prompt.call, last_thinking, last_tool_names)}")
         end
 
         if RailsConsoleAi.configuration.debug
@@ -871,6 +930,8 @@ module RailsConsoleAi
         end
         total_input += result.input_tokens || 0
         total_output += result.output_tokens || 0
+        total_cache_read += result.cache_read_input_tokens || 0
+        total_cache_write += result.cache_write_input_tokens || 0
 
         break if @channel.cancelled?
 
@@ -979,7 +1040,7 @@ module RailsConsoleAi
             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." }
+            add_nudge.call("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
 
@@ -994,20 +1055,21 @@ module RailsConsoleAi
           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." }
+            add_nudge.call("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.")
+        prompt_tokens = total_prompt.call
+        if config.token_stop_threshold && prompt_tokens >= config.token_stop_threshold
+          @channel.display_status("  Token budget exceeded (#{format_tokens(prompt_tokens)} prompt 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
+        elsif config.token_nudge_threshold && prompt_tokens >= 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." }
+          @channel.display_status("  High token usage (#{format_tokens(prompt_tokens)} prompt tokens this request) — nudging model to wrap up.")
+          add_nudge.call("This investigation has consumed #{format_tokens(prompt_tokens)} prompt 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
@@ -1037,10 +1099,16 @@ module RailsConsoleAi
         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)
+        add_nudge.call(final_nudge)
+        # Must be chat_with_tools, not chat: the transcript contains
+        # tool_use/tool_result blocks, and Bedrock/Anthropic reject those unless
+        # the request also defines tools. Any tool calls in the response are
+        # ignored — only the text is used.
+        result = provider.chat_with_tools(messages, tools: tools, system_prompt: active_system_prompt)
         total_input += result.input_tokens || 0
         total_output += result.output_tokens || 0
+        total_cache_read += result.cache_read_input_tokens || 0
+        total_cache_write += result.cache_write_input_tokens || 0
       end
 
       last_llm_stats = result ? format_llm_stats(result) : nil
@@ -1048,6 +1116,8 @@ module RailsConsoleAi
         text: result ? result.text : '',
         input_tokens: total_input,
         output_tokens: total_output,
+        cache_read_input_tokens: total_cache_read,
+        cache_write_input_tokens: total_cache_write,
         stop_reason: result ? result.stop_reason : :end_turn
       )
       [final_result, new_messages, last_llm_stats]
@@ -1056,6 +1126,8 @@ module RailsConsoleAi
     def track_usage(result)
       @total_input_tokens += result.input_tokens || 0
       @total_output_tokens += result.output_tokens || 0
+      @total_cache_read_tokens += result.cache_read_input_tokens || 0
+      @total_cache_write_tokens += result.cache_write_input_tokens || 0
 
       model = effective_model
       @token_usage[model][:input] += result.input_tokens || 0
@@ -1104,6 +1176,8 @@ module RailsConsoleAi
       merged = attrs.merge(
         input_tokens: @total_input_tokens,
         output_tokens: @total_output_tokens,
+        cache_read_tokens: @total_cache_read_tokens,
+        cache_write_tokens: @total_cache_write_tokens,
         duration_ms: duration_ms,
         model: effective_model
       )
@@ -1122,6 +1196,18 @@ module RailsConsoleAi
       chars / 4
     end
 
+    # The four usage buckets each bill at their own rate. `input_tokens` from the
+    # API is the UNCACHED remainder — cached tokens are reported separately and are
+    # not part of it (total prompt size is input + cache_read + cache_write), so
+    # discounting cache_read out of input double-counts and can drive a cost
+    # negative. Every cost readout goes through here.
+    def usage_cost(pricing, input:, output:, cache_read: 0, cache_write: 0)
+      ((input || 0) * pricing[:input]) +
+        ((output || 0) * pricing[:output]) +
+        ((cache_read || 0) * (pricing[:cache_read] || 0)) +
+        ((cache_write || 0) * (pricing[:cache_write] || 0))
+    end
+
     def format_tokens(count)
       if count >= 1_000_000
         "#{(count / 1_000_000.0).round(1)}M"
@@ -1474,14 +1560,10 @@ module RailsConsoleAi
       cache_w = result.cache_write_input_tokens || 0
       parts << "cache r: #{format_tokens(cache_r)} w: #{format_tokens(cache_w)}" if cache_r > 0 || cache_w > 0
       model = effective_model
-      pricing = Configuration.pricing_for(model)
+      pricing = Configuration.pricing_for(model, cache_ttl: RailsConsoleAi.configuration.resolved_cache_ttl)
       if pricing
-        cost = ((result.input_tokens || 0) * pricing[:input]) + ((result.output_tokens || 0) * pricing[:output])
-        if (cache_r > 0 || cache_w > 0) && pricing[:cache_read]
-          cost -= cache_r * pricing[:input]
-          cost += cache_r * pricing[:cache_read]
-          cost += cache_w * (pricing[:cache_write] - pricing[:input])
-        end
+        cost = usage_cost(pricing, input: result.input_tokens, output: result.output_tokens,
+                                   cache_read: cache_r, cache_write: cache_w)
         parts << "~$#{'%.4f' % cost}"
       end
       parts.join(' | ')
@@ -1507,7 +1589,7 @@ module RailsConsoleAi
       input_t = result.input_tokens || 0
       output_t = result.output_tokens || 0
       model = effective_model
-      pricing = Configuration.pricing_for(model)
+      pricing = Configuration.pricing_for(model, cache_ttl: RailsConsoleAi.configuration.resolved_cache_ttl)
       pricing ||= { input: 0.0, output: 0.0 } if RailsConsoleAi.configuration.provider == :local
 
       cache_r = result.cache_read_input_tokens || 0
@@ -1516,12 +1598,8 @@ module RailsConsoleAi
       parts << "cache r: #{format_tokens(cache_r)} w: #{format_tokens(cache_w)}" if cache_r > 0 || cache_w > 0
 
       if pricing
-        cost = (input_t * pricing[:input]) + (output_t * pricing[:output])
-        if (cache_r > 0 || cache_w > 0) && pricing[:cache_read]
-          cost -= cache_r * pricing[:input]
-          cost += cache_r * pricing[:cache_read]
-          cost += cache_w * (pricing[:cache_write] - pricing[:input])
-        end
+        cost = usage_cost(pricing, input: input_t, output: output_t,
+                                   cache_read: cache_r, cache_write: cache_w)
         session_cost = (total_input * pricing[:input]) + (total_output * pricing[:output])
         parts << "~$#{'%.4f' % cost}"
         $stderr.puts "\n#{d}[debug]   ← response: #{parts.join(' | ')}  (session: ~$#{'%.4f' % session_cost})#{r}"

data/lib/rails_console_ai/providers/anthropic.rb

@@ -51,24 +51,24 @@ module RailsConsoleAi
         body = {
           model: config.resolved_model,
           max_tokens: config.resolved_max_tokens,
-          messages: format_messages(messages)
+          messages: mark_conversation_breakpoint(format_messages(messages))
         }
         temp = config.resolved_temperature
         body[:temperature] = temp unless temp.nil?
         if system_prompt
           body[:system] = [
-            { 'type' => 'text', 'text' => system_prompt, 'cache_control' => { 'type' => 'ephemeral' } }
+            { 'type' => 'text', 'text' => system_prompt, 'cache_control' => cache_control }
           ]
         end
         if tools
           anthropic_tools = tools.to_anthropic_format
-          anthropic_tools.last['cache_control'] = { 'type' => 'ephemeral' } if anthropic_tools.any?
+          anthropic_tools.last['cache_control'] = cache_control if anthropic_tools.any?
           body[:tools] = anthropic_tools
         end
 
         json_body = JSON.generate(body)
         debug_request("#{API_URL}/v1/messages", body)
-        response = conn.post('/v1/messages', json_body)
+        response = with_retries { conn.post('/v1/messages', json_body) }
         debug_response(response.body)
         data = parse_response(response)
         usage = data['usage'] || {}
@@ -87,16 +87,60 @@ module RailsConsoleAi
         )
       end
 
+      # Text content is always rendered as a one-element block array, even though
+      # the API accepts a bare string. The breakpoint below can only be attached
+      # to a block, so a string tail would have to be promoted to a block — and
+      # then rendered back as a string on the next request, once it is no longer
+      # the tail. That byte-level flip-flop would break the prefix at exactly the
+      # message the next request needs to read from cache. Rendering one shape
+      # always keeps the prefix stable.
+      #
+      # Empty content is left alone: an empty text block is rejected outright.
       def format_messages(messages)
         messages.map do |msg|
-          if msg[:content].is_a?(Array)
-            { role: msg[:role].to_s, content: msg[:content] }
-          else
-            { role: msg[:role].to_s, content: msg[:content].to_s }
-          end
+          content = msg[:content]
+          content =
+            if content.is_a?(Array) || content.to_s.strip.empty?
+              content
+            else
+              [{ 'type' => 'text', 'text' => content.to_s }]
+            end
+          { role: msg[:role].to_s, content: content }
         end
       end
 
+      def cache_control
+        ttl = config.respond_to?(:resolved_cache_ttl) ? config.resolved_cache_ttl : nil
+        ttl ? { 'type' => 'ephemeral', 'ttl' => ttl } : { 'type' => 'ephemeral' }
+      end
+
+      # Caching `tools` and `system` only covers the static prefix. Every round of
+      # a tool loop resends the whole accumulated conversation, so without a
+      # breakpoint in `messages` the history — which is nearly all of the tokens —
+      # is re-billed at full input price every round, and a task's cost grows with
+      # roughly the square of its round count.
+      #
+      # The breakpoint moves to the end of the array on every request. Breakpoints
+      # written by earlier requests stay valid read points, so each round reads
+      # everything accumulated so far at ~0.1x and writes only what the last round
+      # added. Blocks are duped before marking: `format_messages` passes content
+      # arrays through by reference and they belong to the caller's history.
+      def mark_conversation_breakpoint(formatted)
+        return formatted if formatted.empty?
+
+        last = formatted.last
+        # Anything not already a block array is empty content (see #format_messages)
+        # — nothing to cache there.
+        return formatted unless last[:content].is_a?(Array)
+
+        blocks = last[:content].map { |b| b.is_a?(Hash) ? b.dup : b }
+        target = blocks.last
+        return formatted unless target.is_a?(Hash)
+        target['cache_control'] = cache_control
+
+        formatted[0..-2] + [last.merge(content: blocks)]
+      end
+
       def extract_text(data)
         content = data['content']
         return '' unless content.is_a?(Array)

data/lib/rails_console_ai/providers/base.rb

@@ -28,17 +28,82 @@ module RailsConsoleAi
 
       private
 
+      # Read and connect timeouts are separate budgets. Establishing the TCP/TLS
+      # connection either happens in a couple of seconds or is not going to, while
+      # generation legitimately takes minutes with adaptive thinking and a large
+      # output cap — sharing one value between them means either a connect timeout
+      # that hangs or a read timeout that cuts off generation mid-stream. A cut-off
+      # request loses the turn AND the tokens already spent producing it.
       def build_connection(url, headers = {})
         Faraday.new(url: url) do |f|
-          t = config.respond_to?(:resolved_timeout) ? config.resolved_timeout : config.timeout
-          f.options.timeout = t
-          f.options.open_timeout = t
+          f.options.timeout = config.respond_to?(:resolved_timeout) ? config.resolved_timeout : config.timeout
+          f.options.open_timeout = config.respond_to?(:open_timeout) ? config.open_timeout : 10
           f.headers.update(headers)
           f.headers['Content-Type'] = 'application/json'
           f.adapter Faraday.default_adapter
         end
       end
 
+      # Transient failures worth another attempt: rate limits, upstream overload,
+      # and connections that never got established. Deliberately NOT retried:
+      #
+      # - Timeouts. A request that used its whole read budget is not obviously
+      #   going to do better on a second try, and each retry both doubles the wait
+      #   and pays again for a generation nobody will read. Raise instead, and say
+      #   which knob to turn.
+      # - 4xx other than 429. A malformed request stays malformed.
+      RETRYABLE_STATUSES = [408, 409, 429, 500, 502, 503, 504, 529].freeze
+
+      def with_retries
+        max = config.respond_to?(:max_retries) ? config.max_retries.to_i : 2
+        attempt = 0
+
+        loop do
+          response = nil
+          reason = nil
+
+          begin
+            response = yield
+          rescue Faraday::TimeoutError
+            t = config.respond_to?(:resolved_timeout) ? config.resolved_timeout : config.timeout
+            raise ProviderError,
+              "Provider request timed out after #{t}s. Raise it with: " \
+              "RailsConsoleAi.configure { |c| c.timeout = #{t * 2} }"
+          rescue Faraday::ConnectionFailed, Faraday::SSLError => e
+            raise ProviderError, "Could not reach the provider: #{e.message}" if attempt >= max
+
+            reason = e.class.name
+          end
+
+          if response
+            return response if response.success?
+            return response unless RETRYABLE_STATUSES.include?(response.status)
+            return response if attempt >= max
+
+            reason = "HTTP #{response.status}"
+          end
+
+          delay = retry_delay(response, attempt)
+          RailsConsoleAi.logger.warn(
+            "RailsConsoleAi: #{reason} from provider, retrying in #{'%.1f' % delay}s " \
+            "(attempt #{attempt + 1} of #{max})"
+          )
+          sleep(delay)
+          attempt += 1
+        end
+      end
+
+      # Honour Retry-After when the server sends one; otherwise exponential backoff
+      # with jitter, so concurrent sessions don't retry in lockstep.
+      def retry_delay(response, attempt)
+        header = response && (response.headers['retry-after'] || response.headers['Retry-After'])
+        if header && header.to_f > 0
+          [header.to_f, 60.0].min
+        else
+          (2**attempt) + rand
+        end
+      end
+
       def debug_request(url, body)
         return unless config.debug
 

data/lib/rails_console_ai/providers/bedrock.rb

@@ -46,17 +46,17 @@ module RailsConsoleAi
         inference[:temperature] = temp unless temp.nil?
         params = {
           model_id: config.resolved_model,
-          messages: format_messages(messages),
+          messages: mark_conversation_breakpoint(format_messages(messages)),
           inference_config: inference
         }
         if system_prompt
           sys_blocks = [{ text: system_prompt }]
-          sys_blocks << { cache_point: { type: 'default' } } if cache_supported?
+          sys_blocks << cache_point if cache_supported?
           params[:system] = sys_blocks
         end
         if tools
           bedrock_tools = tools.to_bedrock_format
-          bedrock_tools << { cache_point: { type: 'default' } } if bedrock_tools.any? && cache_supported?
+          bedrock_tools << cache_point if bedrock_tools.any? && cache_supported?
           params[:tool_config] = { tools: bedrock_tools }
         end
 
@@ -96,6 +96,10 @@ module RailsConsoleAi
           client_opts[:region] = region if region && !region.empty?
           t = config.respond_to?(:resolved_timeout) ? config.resolved_timeout : config.timeout
           client_opts[:http_read_timeout] = t
+          # Separate budget from generation time, same reasoning as
+          # Providers::Base#build_connection. The AWS SDK does its own retrying of
+          # throttling and 5xx, so there is no with_retries wrapper on this path.
+          client_opts[:http_open_timeout] = config.open_timeout if config.respond_to?(:open_timeout)
           Aws::BedrockRuntime::Client.new(client_opts)
         end
       end
@@ -141,6 +145,46 @@ module RailsConsoleAi
         merged
       end
 
+      # Converse takes a cache breakpoint as a content block. `ttl` is optional and
+      # only present on newer aws-sdk-bedrockruntime versions — the SDK validates
+      # params against its own struct and raises on an unknown member, so the
+      # member is probed rather than assumed. Omitting it means the 5-minute
+      # default, which is also what `cache_ttl = nil` asks for.
+      def cache_point
+        ttl = config.respond_to?(:resolved_cache_ttl) ? config.resolved_cache_ttl : nil
+        return { cache_point: { type: 'default' } } unless ttl && cache_ttl_supported?
+
+        { cache_point: { type: 'default', ttl: ttl } }
+      end
+
+      def cache_ttl_supported?
+        return @cache_ttl_supported if defined?(@cache_ttl_supported)
+
+        # The struct is only defined once aws-sdk-bedrockruntime is loaded, and
+        # #client does that lazily. Probing first would fail-open to "no TTL" on
+        # the first request of the process — silently, which is the failure mode
+        # this whole change exists to avoid. #client is memoized and needed a few
+        # lines later anyway.
+        client
+
+        @cache_ttl_supported =
+          defined?(Aws::BedrockRuntime::Types::CachePointBlock) &&
+          Aws::BedrockRuntime::Types::CachePointBlock.members.include?(:ttl)
+      end
+
+      # Same reasoning as Providers::Anthropic#mark_conversation_breakpoint: the
+      # system/tools cache points only cover the static prefix, so without a cache
+      # point in the conversation the accumulated history is re-billed at full
+      # price on every round of a tool loop. `format_messages` has already duped
+      # the content arrays, so appending is safe.
+      def mark_conversation_breakpoint(formatted)
+        return formatted unless cache_supported?
+        return formatted if formatted.empty?
+
+        formatted.last[:content] << cache_point
+        formatted
+      end
+
       def extract_text(response)
         content = response.output&.message&.content
         return '' unless content.is_a?(Array)

data/lib/rails_console_ai/providers/openai.rb

@@ -59,7 +59,7 @@ module RailsConsoleAi
 
         json_body = JSON.generate(body)
         debug_request("#{API_URL}/v1/chat/completions", body)
-        response = conn.post('/v1/chat/completions', json_body)
+        response = with_retries { conn.post('/v1/chat/completions', json_body) }
         debug_response(response.body)
         data = parse_response(response)
         usage = data['usage'] || {}

data/lib/rails_console_ai/session_logger.rb

@@ -10,6 +10,8 @@ module RailsConsoleAi
           conversation:  Array(attrs[:conversation]).to_json,
           input_tokens:  attrs[:input_tokens] || 0,
           output_tokens: attrs[:output_tokens] || 0,
+          cache_read_tokens:  attrs[:cache_read_tokens] || 0,
+          cache_write_tokens: attrs[:cache_write_tokens] || 0,
           user_name:     attrs[:user_name] || current_user_name,
           mode:          attrs[:mode].to_s,
           name:          attrs[:name],
@@ -59,6 +61,8 @@ module RailsConsoleAi
         updates[:conversation]  = Array(attrs[:conversation]).to_json if attrs.key?(:conversation)
         updates[:input_tokens]  = attrs[:input_tokens]  if attrs.key?(:input_tokens)
         updates[:output_tokens] = attrs[:output_tokens] if attrs.key?(:output_tokens)
+        updates[:cache_read_tokens]  = attrs[:cache_read_tokens]  if attrs.key?(:cache_read_tokens)
+        updates[:cache_write_tokens] = attrs[:cache_write_tokens] if attrs.key?(:cache_write_tokens)
         updates[:code_executed] = attrs[:code_executed]  if attrs.key?(:code_executed)
         updates[:code_output]   = attrs[:code_output]    if attrs.key?(:code_output)
         updates[:code_result]   = attrs[:code_result]    if attrs.key?(:code_result)

data/lib/rails_console_ai/slack_bot.rb

@@ -739,7 +739,7 @@ module RailsConsoleAi
       total_cost = 0.0
 
       token_usage.each do |model, usage|
-        pricing = Configuration.pricing_for(model)
+        pricing = Configuration.pricing_for(model, cache_ttl: RailsConsoleAi.configuration.resolved_cache_ttl)
         pricing ||= { input: 0.0, output: 0.0 } if RailsConsoleAi.configuration.provider == :local
         input_str = "in: #{usage[:input]}"
         output_str = "out: #{usage[:output]}"
@@ -749,9 +749,11 @@ module RailsConsoleAi
           cache_read = usage[:cache_read] || 0
           cache_write = usage[:cache_write] || 0
           if (cache_read > 0 || cache_write > 0) && pricing[:cache_read]
-            cost -= cache_read * pricing[:input]
+            # input_tokens excludes cached tokens — bill each bucket at its own
+            # rate rather than discounting cache_read out of input (see
+            # ConversationEngine#display_cost_summary).
             cost += cache_read * pricing[:cache_read]
-            cost += cache_write * (pricing[:cache_write] - pricing[:input])
+            cost += cache_write * pricing[:cache_write]
           end
           total_cost += cost
           cache_str = ""

data/lib/rails_console_ai/sub_agent.rb

@@ -144,13 +144,18 @@ module RailsConsoleAi
       end
 
       if exhausted
-        messages << { role: :user, content: "Provide your best answer now based on what you've learned." }
-        result = provider.chat(messages, system_prompt: system_prompt)
+        messages << { role: :user, content: "Provide your best answer now based on what you've learned. Do not call any more tools." }
+        # Must be chat_with_tools, not chat: the transcript contains
+        # tool_use/tool_result blocks, and Bedrock/Anthropic reject those unless
+        # the request also defines tools. Any tool calls in the response are
+        # ignored — only the text is used.
+        result = provider.chat_with_tools(messages, tools: tools, system_prompt: system_prompt)
         @input_tokens += result.input_tokens || 0
         @output_tokens += result.output_tokens || 0
       end
 
-      result&.text || '(sub-agent returned no result)'
+      text = result&.text.to_s
+      text.strip.empty? ? '(sub-agent returned no result)' : text
     end
 
     def format_user_interruption(messages)

data/lib/rails_console_ai/version.rb

@@ -1,3 +1,3 @@
 module RailsConsoleAi
-  VERSION = '0.34.0'.freeze
+  VERSION = '0.35.0'.freeze
 end

data/lib/rails_console_ai.rb

@@ -154,6 +154,8 @@ module RailsConsoleAi
           t.text    :conversation,  null: false
           t.integer :input_tokens,  default: 0
           t.integer :output_tokens, default: 0
+          t.integer :cache_read_tokens,  default: 0
+          t.integer :cache_write_tokens, default: 0
           t.string  :user_name,     limit: 255
           t.string  :mode,          limit: 20, null: false
           t.text    :code_executed
@@ -397,6 +399,18 @@ module RailsConsoleAi
         migrations << 'options'
       end
 
+      # Without these, a session row records only the UNCACHED remainder of its
+      # input and the admin cost column reads near-zero for every cached session.
+      unless conn.column_exists?(table, :cache_read_tokens)
+        conn.add_column(table, :cache_read_tokens, :integer, default: 0)
+        migrations << 'cache_read_tokens'
+      end
+
+      unless conn.column_exists?(table, :cache_write_tokens)
+        conn.add_column(table, :cache_write_tokens, :integer, default: 0)
+        migrations << 'cache_write_tokens'
+      end
+
       unless conn.index_exists?(table, [:mode, :status], name: 'idx_rca_sessions_mode_status')
         conn.add_index(table, [:mode, :status], name: 'idx_rca_sessions_mode_status')
         migrations << 'idx_rca_sessions_mode_status'

metadata

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