rails_console_ai 0.27.0 → 0.29.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db0c0b3b95cc349906845d4058e1eadc6be4ab67e25f32a4b8e4262e61340a87
-  data.tar.gz: 0ba79ae87d8975193b2b6033279dc41a8841cf71e7f015ce8f36dafa6d62d463
+  metadata.gz: 30c7955113bc3e4ce45989fcc0e93034185fbabc0e95acfa01df56ec397900b5
+  data.tar.gz: 87b0399d973e448404b234820067ed2f20d4148f78613963904c9e288a17d87a
 SHA512:
-  metadata.gz: 615da46e5aa24149783309d69a3b739db1170459c1bf6d929c8ecfc875fbc0654117a7c5d15057aaf7d421660afa9959192f4112b25e722e5e224ce3de768fb0
-  data.tar.gz: cf807c3dfc0fae08a79013606c5e00383bc26994461c02e4135f8efb495540a0f677bff62eae01c2f396e9ce2de8ede7c82a95415b69831425447aa93361dbdb
+  metadata.gz: ad1091c711239e286408f0133378c3597c83075b3f9435a40f43bf2df4fa279cf459cf3af84c58027842d2da4c8bccc5d11bfbec616c6e3ec1212784ad59b764
+  data.tar.gz: 61ea9cc3afd50b35ec3d0740b723a076175731d1289c4a98ee5727aaec78c993abb0b78637cb6ac7ef4b550b81b473ff287d83c32405c8fbd345dbf05b0b3b72

data/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.29.0]
+
+- Allow steering Slack conversations mid-run by sending follow-up messages that are folded in as user guidance at the next tool-loop boundary
+- Propagate steering guidance into sub-agent runs so interruptions are seen by both the main engine and any active sub-agent
+
+## [0.28.0]
+
+- Add `bin/smoke_model.rb` to smoke-test new models (plain, tool, parallel, cache checks)
+- Support Claude Opus 4.7 by omitting the `temperature` parameter for models that reject it
+- Show both estimated request tokens and total billed tokens in LLM round status
+- Auto-upgrade to thinking model on "think harder/deeper/carefully" phrases in Slack as well as console
+- Fix cancelled code execution state persisting into the next user turn
+
 ## [0.26.0]
 
 - Add sub-agent support

data/README.md

@@ -352,6 +352,39 @@ end
 
 Timeout is automatically raised to 300s minimum for local models to account for slower inference.
 
+### Testing a new model
+
+Before adopting a new Claude model, smoke-test it against the Anthropic or Bedrock provider with `bin/smoke_model.rb`. The script runs four checks and exits non-zero on any failure:
+
+| check    | what it verifies                                                                 |
+| -------- | -------------------------------------------------------------------------------- |
+| plain    | the model returns text for a basic prompt                                        |
+| tool     | a single tool call → tool result → final answer round-trip works                 |
+| parallel | the model issues multiple tool calls in one response when asked                  |
+| cache    | a long system prompt is written to and read from the prompt cache (with retry)  |
+
+```bash
+# Anthropic — provider inferred from the `claude-` prefix
+ANTHROPIC_API_KEY=sk-ant-... bin/smoke_model.rb --model claude-opus-4-7
+
+# Bedrock — provider inferred from the regional `us.anthropic.` prefix.
+# Requires the aws-sdk-bedrockruntime gem and AWS credentials in the environment.
+bin/smoke_model.rb --model us.anthropic.claude-opus-4-7
+
+# Bedrock in another region
+bin/smoke_model.rb --model eu.anthropic.claude-opus-4-7 --region eu-west-1
+
+# Subset of checks, e.g. when iterating on cache behavior
+bin/smoke_model.rb --model claude-sonnet-4-6 --checks cache
+
+# Force a provider when the model ID is ambiguous
+bin/smoke_model.rb --provider anthropic --model claude-opus-4-7
+```
+
+`DEBUG=1` enables the providers' raw request/response logging.
+
+If the model rejects a parameter the gem sends by default (e.g. opus-4-7 deprecated `temperature`), add the model ID to `Configuration::MODELS_WITHOUT_TEMPERATURE` in `lib/rails_console_ai/configuration.rb` so the providers omit the field.
+
 ## Configuration
 
 ```ruby

data/lib/rails_console_ai/channel/console.rb

@@ -223,8 +223,7 @@ module RailsConsoleAi
           # Add to Readline history
           Readline::HISTORY.push(input) unless input == Readline::HISTORY.to_a.last
 
-          # Auto-upgrade to thinking model on "think harder" phrases
-          @engine.upgrade_to_thinking_model if input =~ /think\s*harder/i
+          @engine.maybe_auto_upgrade_thinking(input)
 
           @engine.set_interactive_query(input)
           @engine.add_user_message(input)

data/lib/rails_console_ai/channel/slack.rb

@@ -11,6 +11,9 @@ module RailsConsoleAi
         @thread_ts = thread_ts
         @user_name = user_name
         @reply_queue = Queue.new
+        @guidance_main = []
+        @guidance_sub = []
+        @guidance_mutex = Mutex.new
         @cancelled = false
         @log_prefix = "[#{@channel_id}/#{@thread_ts}] @#{@user_name}"
         @output_log = StringIO.new
@@ -18,6 +21,36 @@ module RailsConsoleAi
 
       def cancel!
         @cancelled = true
+        @guidance_mutex.synchronize do
+          @guidance_main.clear
+          @guidance_sub.clear
+        end
+      end
+
+      # Guidance is broadcast to both the main-engine queue and the sub-agent queue
+      # so a steering message arriving during a sub-agent run is seen by both layers
+      # (sub-agent reacts immediately; main engine reacts after delegate_task returns).
+      def add_guidance(text)
+        @guidance_mutex.synchronize do
+          @guidance_main << text
+          @guidance_sub << text
+        end
+      end
+
+      def drain_guidance(scope: :main)
+        @guidance_mutex.synchronize do
+          arr = scope == :sub ? @guidance_sub : @guidance_main
+          pending = arr.dup
+          arr.clear
+          pending
+        end
+      end
+
+      def pending_guidance?(scope: :main)
+        @guidance_mutex.synchronize do
+          arr = scope == :sub ? @guidance_sub : @guidance_main
+          !arr.empty?
+        end
       end
 
       def cancelled?

data/lib/rails_console_ai/channel/sub_agent.rb

@@ -64,6 +64,18 @@ module RailsConsoleAi
         @parent.cancelled?
       end
 
+      def pending_guidance?
+        @parent.respond_to?(:pending_guidance?) && @parent.pending_guidance?(scope: :sub)
+      end
+
+      def drain_guidance
+        @parent.respond_to?(:drain_guidance) ? @parent.drain_guidance(scope: :sub) : []
+      end
+
+      def add_guidance(text)
+        @parent.add_guidance(text) if @parent.respond_to?(:add_guidance)
+      end
+
       def supports_danger?
         false  # Sub-agents must never silently bypass safety guards
       end

data/lib/rails_console_ai/configuration.rb

@@ -1,3 +1,5 @@
+require 'set'
+
 module RailsConsoleAi
   class Configuration
     PROVIDERS = %i[anthropic openai local bedrock].freeze
@@ -18,6 +20,17 @@ module RailsConsoleAi
       'claude-opus-4-6'   => 4_096,
     }.freeze
 
+    # Models that reject the `temperature` parameter. Configuration#resolved_temperature
+    # returns nil for these so providers can omit the field from the request.
+    MODELS_WITHOUT_TEMPERATURE = Set.new(%w[
+      claude-opus-4-7
+      anthropic.claude-opus-4-7
+      us.anthropic.claude-opus-4-7
+      eu.anthropic.claude-opus-4-7
+      jp.anthropic.claude-opus-4-7
+      global.anthropic.claude-opus-4-7
+    ]).freeze
+
     attr_accessor :provider, :api_key, :model, :thinking_model, :max_tokens,
                   :auto_execute, :temperature,
                   :timeout, :debug, :max_tool_rounds,
@@ -179,6 +192,13 @@ module RailsConsoleAi
       DEFAULT_MAX_TOKENS.fetch(resolved_model, 4096)
     end
 
+    # Returns nil for models that reject the `temperature` parameter (e.g. opus-4-7).
+    # Providers should use this in place of @temperature.
+    def resolved_temperature
+      return nil if MODELS_WITHOUT_TEMPERATURE.include?(resolved_model)
+      @temperature
+    end
+
     def resolved_thinking_model
       return @thinking_model if @thinking_model && !@thinking_model.empty?
 

data/lib/rails_console_ai/conversation_engine.rb

@@ -110,6 +110,7 @@ module RailsConsoleAi
       init_interactive unless @interactive_start
       @channel.log_input(text) if @channel.respond_to?(:log_input)
       @interactive_query ||= text
+      maybe_auto_upgrade_thinking(text)
       @history << { role: :user, content: text }
 
       status = send_and_execute
@@ -450,6 +451,13 @@ module RailsConsoleAi
       parts.compact.join("\n\n")
     end
 
+    AUTO_THINK_PATTERN = /\bthink\s+(harder|deeper|hard|carefully|more\s+carefully)\b/i
+
+    def maybe_auto_upgrade_thinking(text)
+      return unless text.is_a?(String) && text =~ AUTO_THINK_PATTERN
+      upgrade_to_thinking_model
+    end
+
     def upgrade_to_thinking_model
       config = RailsConsoleAi.configuration
       current = effective_model
@@ -777,6 +785,7 @@ module RailsConsoleAi
       require 'rails_console_ai/tools/registry'
       tools = tools_override || Tools::Registry.new(executor: @executor, channel: @channel)
       active_system_prompt = system_prompt || context
+      @executor.reset_cancelled! if @executor
       max_rounds = RailsConsoleAi.configuration.max_tool_rounds
       total_input = 0
       total_output = 0
@@ -794,21 +803,32 @@ module RailsConsoleAi
           break
         end
 
+        if round > 0 && @channel.respond_to?(:pending_guidance?) && @channel.pending_guidance?
+          pending = @channel.drain_guidance
+          guidance_text = format_user_interruption(pending)
+          guidance_msg = { role: :user, content: guidance_text }
+          messages << guidance_msg
+          new_messages << guidance_msg
+          @channel.display_status("  Steering: incorporating user guidance.")
+        end
+
         if round == 0
           @channel.display_status("  Thinking...")
-        else
-          if last_thinking
-            last_thinking.split("\n").each do |line|
-              @channel.display_thinking("  #{line}")
-            end
+        elsif last_thinking
+          last_thinking.split("\n").each do |line|
+            @channel.display_thinking("  #{line}")
           end
-          @channel.display_status("  #{llm_status(round, messages, total_input, last_thinking, last_tool_names)}")
         end
 
         # Trim large tool outputs between rounds to prevent context explosion.
         # The LLM can still retrieve omitted outputs via recall_output.
         messages = trim_large_outputs(messages) if round > 0
 
+        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)}")
+        end
+
         if RailsConsoleAi.configuration.debug
           debug_pre_call(round, messages, active_system_prompt, tools, total_input, total_output)
         end
@@ -1012,6 +1032,11 @@ module RailsConsoleAi
 
     # --- Formatting helpers ---
 
+    def estimate_request_tokens(messages)
+      chars = messages.sum { |m| (m[:content] || m['content']).to_s.length }
+      chars / 4
+    end
+
     def format_tokens(count)
       if count >= 1_000_000
         "#{(count / 1_000_000.0).round(1)}M"
@@ -1136,9 +1161,32 @@ module RailsConsoleAi
       str.length > max ? str[0..max] + '...' : str
     end
 
-    def llm_status(round, messages, tokens_so_far, last_thinking = nil, last_tool_names = [])
+    # 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.
+    def format_user_interruption(messages)
+      joined = messages.map { |t| t.to_s.strip }.reject(&:empty?).join("\n\n")
+      <<~MSG.strip
+        [INTERRUPTION FROM USER — REAL-TIME MESSAGE]
+
+        The user sent the following message while you were working on the previous step.
+        They sent it before seeing the result of your last tool call, so it is NOT a
+        reply to that result. It is your most recent direction from the user and
+        supersedes the prior task.
+
+        If they are telling you to stop, halt completely and acknowledge — do not
+        autonomously switch to a different method to accomplish the original task.
+        If their instruction is unclear, ask them what they want before continuing.
+
+        User message:
+        "#{joined}"
+      MSG
+    end
+
+    def llm_status(round, messages, req_tokens, total_billed, last_thinking = nil, last_tool_names = [])
       status = "Calling LLM (round #{round + 1}, #{messages.length} msgs"
-      status += ", ~#{format_tokens(tokens_so_far)} ctx" if tokens_so_far > 0
+      status += ", ~#{format_tokens(req_tokens)} ctx" if req_tokens > 0
+      status += ", ~#{format_tokens(total_billed)} total" if total_billed > 0
       status += ")"
       if !last_thinking && last_tool_names.any?
         counts = last_tool_names.tally

data/lib/rails_console_ai/executor.rb

@@ -206,6 +206,10 @@ module RailsConsoleAi
       @last_cancelled
     end
 
+    def reset_cancelled!
+      @last_cancelled = false
+    end
+
     def confirm_and_execute(code)
       return nil if code.nil? || code.strip.empty?
 

data/lib/rails_console_ai/providers/anthropic.rb

@@ -51,9 +51,10 @@ module RailsConsoleAi
         body = {
           model: config.resolved_model,
           max_tokens: config.resolved_max_tokens,
-          temperature: config.temperature,
           messages: 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' } }

data/lib/rails_console_ai/providers/bedrock.rb

@@ -41,13 +41,13 @@ module RailsConsoleAi
       private
 
       def call_api(messages, system_prompt: nil, tools: nil)
+        inference = { max_tokens: config.resolved_max_tokens }
+        temp = config.resolved_temperature
+        inference[:temperature] = temp unless temp.nil?
         params = {
           model_id: config.resolved_model,
           messages: format_messages(messages),
-          inference_config: {
-            max_tokens: config.resolved_max_tokens,
-            temperature: config.temperature
-          }
+          inference_config: inference
         }
         if system_prompt
           sys_blocks = [{ text: system_prompt }]

data/lib/rails_console_ai/providers/local.rb

@@ -21,9 +21,10 @@ module RailsConsoleAi
         body = {
           model: config.resolved_model,
           max_tokens: config.resolved_max_tokens,
-          temperature: config.temperature,
           messages: formatted
         }
+        temp = config.resolved_temperature
+        body[:temperature] = temp unless temp.nil?
         body[:tools] = tools.to_openai_format if tools
 
         estimated_input_tokens = estimate_tokens(formatted, system_prompt, tools)

data/lib/rails_console_ai/providers/openai.rb

@@ -51,9 +51,10 @@ module RailsConsoleAi
         body = {
           model: config.resolved_model,
           max_tokens: config.resolved_max_tokens,
-          temperature: config.temperature,
           messages: formatted
         }
+        temp = config.resolved_temperature
+        body[:temperature] = temp unless temp.nil?
         body[:tools] = tools.to_openai_format if tools
 
         json_body = JSON.generate(body)

data/lib/rails_console_ai/slack_bot.rb

@@ -491,6 +491,14 @@ module RailsConsoleAi
         return
       end
 
+      # If the engine is mid-run, treat the message as steering guidance to be
+      # folded in at the next tool-loop boundary instead of restarting.
+      if session[:thread]&.alive? && channel.respond_to?(:add_guidance)
+        channel.add_guidance(text)
+        channel.display("Got it. One moment.")
+        return
+      end
+
       # Otherwise treat as a new message in the conversation
       replace_session_thread(session) do
         Thread.current.report_on_exception = false

data/lib/rails_console_ai/sub_agent.rb

@@ -66,6 +66,12 @@ module RailsConsoleAi
       max_rounds.times do |round|
         break if channel.cancelled?
 
+        if round > 0 && channel.respond_to?(:pending_guidance?) && channel.pending_guidance?
+          pending = channel.drain_guidance
+          messages << { role: :user, content: format_user_interruption(pending) }
+          channel.display_status("  Steering: incorporating user guidance.")
+        end
+
         if round == 0
           channel.display_status("Thinking...")
         end
@@ -147,6 +153,25 @@ module RailsConsoleAi
       result&.text || '(sub-agent returned no result)'
     end
 
+    def format_user_interruption(messages)
+      joined = messages.map { |t| t.to_s.strip }.reject(&:empty?).join("\n\n")
+      <<~MSG.strip
+        [INTERRUPTION FROM USER — REAL-TIME MESSAGE]
+
+        The user sent the following message while you were working. They sent it
+        before seeing your latest tool result, so it is NOT a reply to that result.
+        It is your most recent direction from the user and supersedes the prior task.
+
+        If they are telling you to stop, halt immediately and finish with a brief
+        acknowledgement — do not switch to a different method to accomplish the
+        original task on your own. If unclear, return what you have so far and let
+        the parent agent ask the user.
+
+        User message:
+        "#{joined}"
+      MSG
+    end
+
     def build_provider
       config = RailsConsoleAi.configuration
       model_override = @agent_config['model'] || config.sub_agent_model

data/lib/rails_console_ai/version.rb

@@ -1,3 +1,3 @@
 module RailsConsoleAi
-  VERSION = '0.27.0'.freeze
+  VERSION = '0.29.0'.freeze
 end

metadata

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