rails_console_ai 0.36.0 → 0.38.0

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

@@ -36,6 +36,12 @@
         <span><%= @session.slack_channel_name %></span>
       </div>
     <% end %>
+    <% if @session.try(:slack_thread_ts).present? %>
+      <div class="meta-item">
+        <label>Slack Thread</label>
+        <span class="mono"><%= @session.slack_thread_ts %></span>
+      </div>
+    <% end %>
     <div class="meta-item">
       <label>Provider / Model</label>
       <span><%= @session.provider %> / <%= @session.model %></span>

data/config/routes.rb

@@ -2,6 +2,14 @@ RailsConsoleAi::Engine.routes.draw do
   root to: 'sessions#index'
   resources :sessions, only: [:index, :show]
 
+  # Addressed by token, not id — see ArtifactsController#load_artifact.
+  resources :artifacts, only: [:index, :show, :destroy] do
+    member do
+      get :raw
+      get :download
+    end
+  end
+
   resources :skills do
     member do
       post :approve

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

@@ -53,6 +53,11 @@ RailsConsoleAi.configure do |config|
   # Run RailsConsoleAi.setup! in the Rails console to create the table
   config.session_logging = true
 
+  # Public base URL of this app, so links the assistant hands out (artifact URLs)
+  # are absolute — a bare path is useless once pasted into Slack or opened on a
+  # phone. Falls back to the app's default_url_options, then to a relative path.
+  # config.base_url = 'https://secure.example.com'
+
   # Database connection for RailsConsoleAi tables (default: ActiveRecord::Base)
   # Set to a class that responds to .connection if tables live on a different DB
   # config.connection_class = Sharding::CentralizedModel

data/lib/rails_console_ai/channel/console.rb

@@ -321,6 +321,8 @@ module RailsConsoleAi
           @engine.upgrade_to_thinking_model
         when '/unthink'
           @engine.downgrade_from_thinking_model
+        when '/cheap'
+          @engine.switch_to_cheap_model
         when /\A\/expand/
           expand_id = input.sub('/expand', '').strip.to_i
           full_output = expand_output(expand_id)
@@ -425,13 +427,14 @@ module RailsConsoleAi
       def display_model_info
         config = RailsConsoleAi.configuration
         model = @engine.effective_model
-        thinking = config.resolved_thinking_model
         pricing = Configuration.pricing_for(model)
 
         @real_stdout.puts "\e[36m  Model info:\e[0m"
         @real_stdout.puts "\e[2m    Provider:        #{config.provider}\e[0m"
-        @real_stdout.puts "\e[2m    Model:           #{model}\e[0m"
-        @real_stdout.puts "\e[2m    Thinking model:  #{thinking}\e[0m"
+        @real_stdout.puts "\e[2m    Model:           #{@engine.effective_model_label} [#{@engine.model_tier}]\e[0m"
+        @real_stdout.puts "\e[2m    Default model:   #{model_with_effort(config.resolved_model, config.effort)}\e[0m"
+        @real_stdout.puts "\e[2m    Thinking model:  #{model_with_effort(config.resolved_thinking_model, config.thinking_effort)}\e[0m"
+        @real_stdout.puts "\e[2m    Cheap model:     #{config.resolved_cheap_model}\e[0m"
         @real_stdout.puts "\e[2m    Max tokens:      #{config.resolved_max_tokens}\e[0m"
         if pricing
           @real_stdout.puts "\e[2m    Pricing:         $#{pricing[:input] * 1_000_000}/M in, $#{pricing[:output] * 1_000_000}/M out\e[0m"
@@ -444,6 +447,11 @@ module RailsConsoleAi
         @real_stdout.puts "\e[2m    OpenRouter URL:  #{config.openrouter_url}\e[0m" if config.openrouter_url
       end
 
+      def model_with_effort(model, effort)
+        effort = Configuration.effort_for(model, effort)
+        effort ? "#{model} (#{effort} effort)" : model
+      end
+
       def handle_name_command(input)
         name = input.sub('/name', '').strip.gsub(/\A(['"])(.*)\1\z/, '\2')
         if name.empty?
@@ -471,6 +479,7 @@ module RailsConsoleAi
         @real_stdout.puts "\e[2m    /model       Show provider, model, and pricing info\e[0m"
         @real_stdout.puts "\e[2m    /think       Switch to thinking model\e[0m"
         @real_stdout.puts "\e[2m    /unthink     Switch back to default model\e[0m"
+        @real_stdout.puts "\e[2m    /cheap       Switch to the cheaper, faster model\e[0m"
         @real_stdout.puts "\e[2m    /compact     Summarize conversation to reduce context\e[0m"
         @real_stdout.puts "\e[2m    /usage       Show session token totals\e[0m"
         @real_stdout.puts "\e[2m    /cost        Show cost estimate by model\e[0m"

data/lib/rails_console_ai/channel/slack.rb

@@ -71,7 +71,7 @@ module RailsConsoleAi
         stripped = strip_ansi(text).strip
         return if stripped.empty?
 
-        if stripped =~ /\AThinking\.\.\.|\AAttempting to fix|\ACancelled|\A_session:/
+        if stripped =~ /\AThinking\.\.\.|\AAttempting to fix|\ACancelled|\A_Session\b/
           post(stripped)
         else
           @output_log.write("#{stripped}\n")

data/lib/rails_console_ai/configuration.rb

@@ -8,19 +8,23 @@ module RailsConsoleAi
     # (us.anthropic.claude-sonnet-5, global.anthropic.claude-opus-4-6-v1).
     #
     # input/output are $ per MTok (converted to per-token in .pricing_for).
-    # Cache pricing is derived: read = 0.1x input, write = 1.25x input.
+    # Cache pricing is derived: read = 0.1x input, write = 1.25x input, unless a
+    # family sets cache_read ($ per MTok) explicitly (opus-5-5 reads at 0.05x).
     # temperature: false marks families that reject the `temperature` parameter
-    # (removed on opus-4-7+, sonnet-5, and fable-5).
+    # (removed on opus-4-7+, sonnet-5+, and fable-5).
+    # effort: false marks families that reject `output_config.effort` (haiku-4-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, context: 1_000_000, temperature: false },
+      'claude-opus-5-5'   => { input: 4.0,  output: 20.0, cache_read: 0.20, 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-5' => { input: 2.0,  output: 10.0, max_tokens: 16_000, context: 1_000_000, temperature: false },
       '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 },
+      'claude-haiku-4-5'  => { input: 1.0,  output: 5.0,  max_tokens: 16_000, context: 200_000,   temperature: true, effort: false },
     }.freeze
 
     # Assumed context window for models with no family entry — local models and
@@ -28,9 +32,10 @@ module RailsConsoleAi
     # little early, over-guessing means no warning before the request is rejected.
     DEFAULT_CONTEXT_WINDOW = 200_000
 
+    EFFORT_LEVELS = %w[low medium high xhigh max].freeze
+
     # 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').
+    # when keys overlap (e.g. 'claude-sonnet-5-5' matches before 'claude-sonnet-5').
     MODEL_FAMILY_KEYS = MODEL_FAMILIES.keys.sort_by { |k| -k.length }.freeze
 
     # Returns the family attributes for a model ID, or nil for unknown models.
@@ -41,6 +46,14 @@ module RailsConsoleAi
       key && MODEL_FAMILIES[key]
     end
 
+    # The effort a model would be sent, or nil when it takes none: unknown models
+    # (OpenAI, local) and families marked effort: false.
+    def self.effort_for(model_id, effort)
+      return nil if effort.nil? || effort.to_s.empty?
+      family = model_family(model_id)
+      family && family[:effort] != false ? effort.to_s : nil
+    end
+
     # Per-token pricing for a model ID, matched by family. Returns
     # { input:, output:, cache_read:, cache_write: } or nil for unknown models.
     # Cache reads bill at 0.1x the base input rate; cache writes at 1.25x for the
@@ -52,7 +65,7 @@ module RailsConsoleAi
       {
         input: input,
         output: family[:output] / 1_000_000,
-        cache_read: input * 0.1,
+        cache_read: family[:cache_read] ? family[:cache_read] / 1_000_000 : input * 0.1,
         cache_write: input * (cache_ttl.to_s == '1h' ? 2.0 : 1.25),
       }
     end
@@ -98,7 +111,8 @@ module RailsConsoleAi
       }
     ].freeze
 
-    attr_accessor :provider, :api_key, :model, :thinking_model, :max_tokens,
+    attr_accessor :provider, :api_key, :model, :thinking_model, :cheap_model, :max_tokens,
+                  :effort, :thinking_effort,
                   :auto_execute, :temperature,
                   :timeout, :open_timeout, :max_retries, :debug, :max_tool_rounds,
                   :error_hints,
@@ -118,13 +132,21 @@ module RailsConsoleAi
                   :user_extra_info,
                   :sub_agent_max_rounds,
                   :sub_agent_model,
-                  :line_editor
+                  :line_editor,
+                  :base_url,
+                  :artifact_date_prefix
 
     def initialize
       @provider     = :anthropic
       @api_key      = nil
       @model        = nil
       @thinking_model = nil
+      @cheap_model  = nil
+      # The default and thinking tiers run the same model by default and differ
+      # only in how hard it thinks. Sent as output_config.effort, and only to
+      # model families that accept it. The cheap tier sends no effort.
+      @effort          = 'medium'
+      @thinking_effort = 'high'
       @max_tokens   = nil
       @auto_execute = false
       @temperature  = 0.2
@@ -179,6 +201,15 @@ module RailsConsoleAi
       # Interactive line editor: :auto prefers Reline (live "/" completion menu)
       # and falls back to Readline. Force one with :reline or :readline.
       @line_editor = :auto
+      # Public base URL of the host app, e.g. "https://secure.apptoto.com". Used
+      # to build links the gem hands out — an artifact URL is read in a console,
+      # pasted into Slack or opened on a phone, where a bare path is useless.
+      # Falls back to the app's default_url_options, then to a relative path.
+      @base_url = nil
+      # Stamp new artifact names with the day they were made ("20260911_Churn
+      # report"), so a list of them reads chronologically. Updates keep the name
+      # and date they were created with.
+      @artifact_date_prefix = true
     end
 
     def resolve_user_extra_info(username)
@@ -277,6 +308,25 @@ module RailsConsoleAi
     def resolved_model
       return @model if @model && !@model.empty?
 
+      case @provider
+      when :anthropic
+        'claude-opus-5-5'
+      when :openai
+        'gpt-5.3-codex'
+      when :openrouter
+        'anthropic/claude-opus-5.5'
+      when :local
+        @local_model
+      when :bedrock
+        'us.anthropic.claude-opus-5-5'
+      end
+    end
+
+    # The model /cheap switches to: faster and cheaper than the default, for
+    # routine lookups where the default's depth isn't needed.
+    def resolved_cheap_model
+      return @cheap_model if @cheap_model && !@cheap_model.empty?
+
       case @provider
       when :anthropic
         'claude-sonnet-5'
@@ -301,13 +351,18 @@ module RailsConsoleAi
     end
 
     # Returns nil for model families that reject the `temperature` parameter
-    # (opus-4-7+, sonnet-5, fable-5) so providers omit the field from the request.
+    # (opus-4-7+, sonnet-5+, fable-5) so providers omit the field from the request.
     def resolved_temperature
       family = self.class.model_family(resolved_model)
       return nil if family && family[:temperature] == false
       @temperature
     end
 
+    # Returns the effort to send for the configured model, or nil to omit it.
+    def resolved_effort
+      self.class.effort_for(resolved_model, @effort)
+    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
@@ -320,15 +375,15 @@ module RailsConsoleAi
 
       case @provider
       when :anthropic
-        'claude-opus-5'
+        'claude-opus-5-5'
       when :openai
         'gpt-5.3-codex'
       when :openrouter
-        'anthropic/claude-opus-5'
+        'anthropic/claude-opus-5.5'
       when :local
         @local_model
       when :bedrock
-        'us.anthropic.claude-opus-5'
+        'us.anthropic.claude-opus-5-5'
       end
     end
 
@@ -347,6 +402,11 @@ module RailsConsoleAi
         raise ConfigurationError, "Unknown provider: #{@provider}. Valid: #{PROVIDERS.join(', ')}"
       end
 
+      { effort: @effort, thinking_effort: @thinking_effort }.each do |name, value|
+        next if value.nil? || EFFORT_LEVELS.include?(value.to_s)
+        raise ConfigurationError, "Invalid #{name}: #{value.inspect}. Valid: #{EFFORT_LEVELS.join(', ')}"
+      end
+
       if @provider == :local
         raise ConfigurationError, "No local_url configured for :local provider." unless @local_url && !@local_url.empty?
       elsif @provider == :bedrock

data/lib/rails_console_ai/context_builder.rb

@@ -48,6 +48,26 @@ module RailsConsoleAi
       lines.join("\n")
     end
 
+    # The index of memory names the model can recall, with the instruction to
+    # look before answering. Public because SubAgent builds its own prompt and
+    # shares this section, so a sub-agent knows the same memories exist.
+    def memory_context
+      return nil unless @config.memories_enabled
+
+      require 'rails_console_ai/tools/memory_tools'
+      summaries = Tools::MemoryTools.new.memory_summaries
+      return nil if summaries.nil? || summaries.empty?
+
+      lines = ["## Memories"]
+      lines.concat(summaries)
+      lines << ""
+      lines << "Call recall_memory (by name) or recall_memories (by keyword) to get details before answering. Do NOT guess from the name alone."
+      lines.join("\n")
+    rescue => e
+      RailsConsoleAi.logger.debug("RailsConsoleAi: memory context failed: #{e.message}")
+      nil
+    end
+
     private
 
     def smart_system_instructions
@@ -102,6 +122,34 @@ module RailsConsoleAi
         - This keeps your conversation context small and efficient.
         - If a custom agent is available for the task (see Agents section), specify it by name.
 
+        You have artifact tools for output that is a document rather than an answer:
+        - When the user asks for a report, summary, export, table or page, build it with
+          save_artifact instead of printing it into the console. Reply with the URL it returns,
+          and tell them the handle so they can ask for it again later.
+        - New artifacts are named with today's date: "Q3 churn summary" is stored as
+          "20260911_Q3 churn summary" and addressed as 20260911-q3-churn-summary. Do not add the
+          date yourself — pass the plain title and it is stamped for you.
+        - Saving under a name that already exists replaces that artifact and bumps its revision.
+          To revise one from an earlier day, pass its exact handle as the name; passing the plain
+          title again makes a fresh artifact under today's date.
+        - When the user refers to an earlier artifact ("update the churn report", "add last month
+          to that table"), use list_artifacts to find its handle, read_artifact to get what is
+          already there, then save_artifact under the SAME name to replace it. Do not start a new
+          one unless they want a new one.
+        - delete_artifact removes one, only when asked.
+        - When the content already exists as a value in the console — a file you read from S3,
+          a string you built in code — do NOT retype it into save_artifact. Your response has an
+          output-token limit, and a large file will be cut off mid-argument and the call thrown
+          away. Save it from Ruby instead, inside execute_code:
+            html = S3.read_file("report.html")
+            RailsConsoleAi.save_artifact(name: "Mathnasium migration", content: html)
+          That is also the only way to store something verbatim: anything you retype is your
+          recollection of the bytes, not the bytes. Use save_artifact for content you are
+          composing yourself.
+        - HTML artifacts render in a sandboxed frame: inline CSS works, but scripts never run and
+          nothing loads over the network. Inline every style and embed the data directly.
+        - Use text/csv or application/json when the user wants data to take elsewhere.
+
         RULES:
         - Give ONE concise answer. Do not offer multiple alternatives or variations.
         - For multi-step tasks, use execute_plan to break the work into small, clear steps.
@@ -195,23 +243,5 @@ module RailsConsoleAi
       RailsConsoleAi.logger.debug("RailsConsoleAi: pinned memory context failed: #{e.message}")
       nil
     end
-
-    def memory_context
-      return nil unless @config.memories_enabled
-
-      require 'rails_console_ai/tools/memory_tools'
-      summaries = Tools::MemoryTools.new.memory_summaries
-      return nil if summaries.nil? || summaries.empty?
-
-      lines = ["## Memories"]
-      lines.concat(summaries)
-      lines << ""
-      lines << "Call recall_memory (by name) or recall_memories (by keyword) to get details before answering. Do NOT guess from the name alone."
-      lines.join("\n")
-    rescue => e
-      RailsConsoleAi.logger.debug("RailsConsoleAi: memory context failed: #{e.message}")
-      nil
-    end
-
   end
 end

data/lib/rails_console_ai/conversation_engine.rb

@@ -13,6 +13,7 @@ module RailsConsoleAi
     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
+    MAX_TRUNCATION_RETRIES = 1           # responses cut off at the output cap → nudge, then stop
 
     def initialize(binding_context:, channel:, slack_thread_ts: nil, slack_channel_name: nil)
       @binding_context = binding_context
@@ -131,6 +132,16 @@ module RailsConsoleAi
       end
     end
 
+    # Creates the session row before the first turn runs, so its id can be
+    # handed out (the Slack bot links to it) while that turn is still going.
+    # Returns nil when session logging is off.
+    def ensure_session_record(query)
+      init_interactive unless @interactive_start
+      @interactive_query ||= query
+      log_interactive_turn(status: 'running') unless @interactive_session_id
+      @interactive_session_id
+    end
+
     def init_guide
       storage = RailsConsoleAi.storage
       existing_guide = begin
@@ -596,38 +607,56 @@ module RailsConsoleAi
       upgrade_to_thinking_model
     end
 
-    def upgrade_to_thinking_model
-      config = RailsConsoleAi.configuration
-      current = effective_model
-      thinking = config.resolved_thinking_model
+    # Three tiers a session can run on. :default and :thinking usually share a
+    # model and differ in effort, so a switch is tracked by tier, not by model ID.
+    MODEL_TIERS = %i[default thinking cheap].freeze
 
-      if current == thinking
-        $stdout.puts "\e[36m  Already using thinking model (#{current}).\e[0m"
-      else
-        @model_override = thinking
-        @provider = nil
-        $stdout.puts "\e[36m  Switched to thinking model: #{thinking}\e[0m"
-      end
-      effective_model
+    def upgrade_to_thinking_model
+      switch_model_tier(:thinking)
     end
 
     def downgrade_from_thinking_model
-      config = RailsConsoleAi.configuration
-      default = config.resolved_model
-      current = effective_model
+      switch_model_tier(:default)
+    end
+
+    def switch_to_cheap_model
+      switch_model_tier(:cheap)
+    end
+
+    def switch_model_tier(tier)
+      raise ArgumentError, "Unknown model tier: #{tier.inspect}" unless MODEL_TIERS.include?(tier)
 
-      if current == default && @model_override.nil?
-        $stdout.puts "\e[36m  Already using default model (#{current}).\e[0m"
+      if tier == model_tier
+        $stdout.puts "\e[36m  Already using #{tier} model (#{effective_model_label}).\e[0m"
       else
-        @model_override = nil
+        @model_tier = tier
         @provider = nil
-        $stdout.puts "\e[36m  Switched back to default model: #{default}\e[0m"
+        $stdout.puts "\e[36m  Switched to #{tier} model: #{effective_model_label}\e[0m"
       end
       effective_model
     end
 
+    def model_tier
+      @model_tier || :default
+    end
+
     def effective_model
-      @model_override || RailsConsoleAi.configuration.resolved_model
+      config = RailsConsoleAi.configuration
+      case model_tier
+      when :thinking then config.resolved_thinking_model
+      when :cheap    then config.resolved_cheap_model
+      else config.resolved_model
+      end
+    end
+
+    def effective_effort
+      tier_config.resolved_effort
+    end
+
+    # "claude-opus-5-5 (high effort)", or the bare model when no effort is sent.
+    def effective_model_label
+      effort = effective_effort
+      effort ? "#{effective_model} (#{effort} effort)" : effective_model
     end
 
     def compact_history
@@ -744,6 +773,9 @@ module RailsConsoleAi
           log_attrs[:user_name] = @channel.mode == 'slack' ? "slack:#{@channel.user_identity}" : @channel.user_identity
         end
         @interactive_session_id = SessionLogger.log(log_attrs)
+        # Tools that persist something (save_artifact) read this to point back at
+        # the conversation that produced it, without needing a handle on the engine.
+        RailsConsoleAi.current_session_id = @interactive_session_id
       end
     end
 
@@ -854,18 +886,24 @@ module RailsConsoleAi
 
     def provider
       @provider ||= begin
-        p = if @model_override
-          config = RailsConsoleAi.configuration.dup
-          config.model = @model_override
-          Providers.build(config)
-        else
-          Providers.build
-        end
+        p = model_tier == :default ? Providers.build : Providers.build(tier_config)
         p.routing_session_id = @routing_session_id if p.respond_to?(:routing_session_id=)
         p
       end
     end
 
+    # The configuration for the current tier. Off the default tier it is a copy,
+    # so a switch never leaks into the global singleton or other sessions.
+    def tier_config
+      config = RailsConsoleAi.configuration
+      return config if model_tier == :default
+
+      config = config.dup
+      config.model = effective_model
+      config.effort = model_tier == :thinking ? config.thinking_effort : nil
+      config
+    end
+
     def context_builder
       @context_builder ||= ContextBuilder.new(channel_mode: @channel.mode, user_name: @channel.user_identity)
     end
@@ -986,6 +1024,7 @@ module RailsConsoleAi
 
       exhausted = false
       wrap_up_reason = nil
+      truncation_nudges = 0
       tool_call_counts = Hash.new(0)
       error_sig_counts = Hash.new(0)
       warned_error_sigs = Set.new
@@ -1045,6 +1084,34 @@ module RailsConsoleAi
           debug_post_call(round, result, @total_input_tokens + total_input, @total_output_tokens + total_output)
         end
 
+        # A response cut off at the output cap has nothing usable in it: the tool
+        # call it was in the middle of writing arrives with half its arguments, so
+        # it is discarded, and only the sentence the model wrote before starting
+        # the call survives. Left unhandled that looks exactly like a finished
+        # turn, and the model retries the same oversized call every time it is
+        # asked again — the identical truncation, forever, at full output cost.
+        # Say so, once, with the way out; the second one ends the turn.
+        if result.truncated?
+          cap = RailsConsoleAi.configuration.resolved_max_tokens
+          @channel.display_warning("  Response hit the #{format_tokens(cap)} output-token cap mid-generation — the incomplete tool call was discarded.")
+          if truncation_nudges >= MAX_TRUNCATION_RETRIES
+            @channel.display_error("  Truncated again. Stopping — see the guidance above, or raise c.max_tokens.")
+            break
+          end
+
+          truncation_nudges += 1
+          add_nudge.call(
+            "Your last response was cut off at the #{cap}-token output limit, so the tool call you were " \
+            "writing was discarded and never ran. Retrying it unchanged will be cut off at exactly the same " \
+            "point. You must make the next response SMALLER. If you were passing a large block of content as " \
+            "a tool argument — the content of an artifact, a file, a long report — do not inline it: run " \
+            "execute_code and have the Ruby build the string and save it directly, e.g. " \
+            "`RailsConsoleAi.save_artifact(name: \"...\", content: some_string)`, which never sends those " \
+            "bytes through your response at all. Otherwise, split the work across several smaller tool calls."
+          )
+          next
+        end
+
         break unless result.tool_use?
 
         last_thinking = (result.text && !result.text.strip.empty?) ? result.text.strip : nil
@@ -1209,6 +1276,9 @@ module RailsConsoleAi
         total_output += result.output_tokens || 0
         total_cache_read += result.cache_read_input_tokens || 0
         total_cache_write += result.cache_write_input_tokens || 0
+        if result.truncated?
+          @channel.display_warning("  The final answer was cut off at the #{format_tokens(RailsConsoleAi.configuration.resolved_max_tokens)} output-token cap — what follows is incomplete.")
+        end
       end
 
       last_llm_stats = result ? format_llm_stats(result) : nil

data/lib/rails_console_ai/providers/anthropic.rb

@@ -55,6 +55,8 @@ module RailsConsoleAi
         }
         temp = config.resolved_temperature
         body[:temperature] = temp unless temp.nil?
+        effort = config.resolved_effort
+        body[:output_config] = { effort: effort } if effort
         if system_prompt
           body[:system] = [
             { 'type' => 'text', 'text' => system_prompt, 'cache_control' => cache_control }
@@ -74,7 +76,7 @@ module RailsConsoleAi
         usage = data['usage'] || {}
 
         tool_calls = extract_tool_calls(data)
-        stop = data['stop_reason'] == 'tool_use' ? :tool_use : :end_turn
+        stop = normalize_stop_reason(data['stop_reason'], %w[tool_use], %w[max_tokens])
 
         ChatResult.new(
           text: extract_text(data),

data/lib/rails_console_ai/providers/base.rb

@@ -29,6 +29,20 @@ module RailsConsoleAi
 
       private
 
+      # Every provider reports "I stopped because I ran out of room" under its own
+      # name, and the obvious mapping — anything that isn't a tool call is a
+      # finished turn — is wrong in a way that costs the whole turn: a response cut
+      # off mid-tool-call arrives with its arguments half-written, the engine sees
+      # :end_turn, discards the partial call and prints whatever preamble the model
+      # managed first. That reads as the model deciding to answer in one sentence.
+      # Naming truncation lets the engine say so and let the model recover.
+      def normalize_stop_reason(raw, tool_values, truncation_values)
+        raw = raw.to_s
+        return :tool_use if tool_values.include?(raw)
+        return :max_tokens if truncation_values.include?(raw)
+        :end_turn
+      end
+
       # 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
@@ -159,6 +173,12 @@ module RailsConsoleAi
       def tool_use?
         stop_reason == :tool_use && tool_calls && !tool_calls.empty?
       end
+
+      # The response hit the output cap mid-generation. Whatever it was writing —
+      # text, or the arguments of a tool call — is incomplete and cannot be used.
+      def truncated?
+        stop_reason == :max_tokens
+      end
     end
 
     def self.build(config = RailsConsoleAi.configuration)

data/lib/rails_console_ai/providers/bedrock.rb

@@ -49,6 +49,9 @@ module RailsConsoleAi
           messages: mark_conversation_breakpoint(format_messages(messages)),
           inference_config: inference
         }
+        # Converse has no effort field; Anthropic request fields ride along here.
+        effort = config.resolved_effort
+        params[:additional_model_request_fields] = { output_config: { effort: effort } } if effort
         if system_prompt
           sys_blocks = [{ text: system_prompt }]
           sys_blocks << cache_point if cache_supported?
@@ -65,7 +68,7 @@ module RailsConsoleAi
         debug_bedrock_response(response)
 
         tool_calls = extract_tool_calls(response)
-        stop = response.stop_reason == 'tool_use' ? :tool_use : :end_turn
+        stop = normalize_stop_reason(response.stop_reason, %w[tool_use], %w[max_tokens])
 
         usage = response.usage
         ChatResult.new(
@@ -78,7 +81,7 @@ module RailsConsoleAi
           stop_reason: stop
         )
       rescue aws_error_class => e
-        raise ProviderError, "AWS Bedrock error: #{e.message}"
+        raise ProviderError, "AWS Bedrock error (#{e.class}): #{e.message}"
       end
 
       def client

data/lib/rails_console_ai/providers/local.rb

@@ -41,7 +41,7 @@ module RailsConsoleAi
           end
         end
 
-        stop = finish_reason == 'tool_calls' ? :tool_use : :end_turn
+        stop = normalize_stop_reason(finish_reason, %w[tool_calls], %w[length])
 
         ChatResult.new(
           text: message['content'] || '',

data/lib/rails_console_ai/providers/openai.rb

@@ -90,7 +90,7 @@ module RailsConsoleAi
         finish_reason = choice['finish_reason']
 
         tool_calls = extract_tool_calls(message)
-        stop = finish_reason == 'tool_calls' ? :tool_use : :end_turn
+        stop = normalize_stop_reason(finish_reason, %w[tool_calls], %w[length])
 
         ChatResult.new(
           text: message['content'] || '',