rails_console_ai 0.35.0 → 0.38.0

data/lib/rails_console_ai/conversation_engine.rb

@@ -1,3 +1,5 @@
+require 'rails_console_ai/slash_commands'
+
 module RailsConsoleAi
   class ConversationEngine
     attr_reader :history, :total_input_tokens, :total_output_tokens,
@@ -11,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
@@ -19,6 +22,7 @@ module RailsConsoleAi
       @slack_channel_name = slack_channel_name
       @executor = Executor.new(binding_context, channel: channel)
       @provider = nil
+      @routing_session_id = SecureRandom.hex(8)
       @context_builder = nil
       @context = nil
       @history = []
@@ -128,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
@@ -255,6 +269,80 @@ module RailsConsoleAi
       execute_direct(code)
     end
 
+    # --- Slash-command invocation of skills and agents ---
+
+    # A skill is a recipe for *this* assistant, and its guard bypasses have to
+    # land on the live executor — so it runs as a normal turn with the recipe
+    # prepended, not in a sub-agent. Returns the user-turn text to send.
+    def skill_command_prompt(skill, request)
+      bypass_methods = Array(skill['bypass_guards_for_methods'])
+      @executor.activate_skill_bypasses(bypass_methods) unless bypass_methods.empty?
+
+      if skill['source'] == :db && skill['id']
+        RailsConsoleAi::Skill.record_use!(skill['id'])
+      end
+
+      @channel.display_status("  Activated skill: #{skill['name']}")
+
+      request = request.to_s.strip
+      task = request.empty? ? "Follow this skill now." : request
+
+      "The user invoked the \"#{skill['name']}\" skill. Follow its procedure.\n\n" \
+        "--- SKILL: #{skill['name']} ---\n#{skill['body']}\n--- END SKILL ---\n\n" \
+        "Their request: #{task}"
+    end
+
+    # An agent is a separate context by definition, so this mirrors delegate_task:
+    # run it, then fold only its summary back into the conversation.
+    def run_agent_command(agent, task)
+      require 'rails_console_ai/sub_agent'
+
+      task = task.to_s.strip
+      if task.empty?
+        @channel.display_warning("  /#{SlashCommands.slugify(agent['name'])} needs a task. Try: /#{SlashCommands.slugify(agent['name'])} <what to investigate>")
+        return
+      end
+
+      @interactive_query ||= "/#{SlashCommands.slugify(agent['name'])} #{task}"
+      log_interactive_turn(status: 'running')
+
+      if agent['source'] == :db && agent['id']
+        RailsConsoleAi::Agent.record_use!(agent['id'])
+      end
+
+      sub = SubAgent.new(
+        task: task,
+        agent_config: agent,
+        binding_context: @executor.binding_context,
+        parent_channel: @channel,
+        executor: @executor
+      )
+
+      begin
+        # Deliberately NOT wrapped in @channel.wrap_llm_call. That wrapper puts the
+        # terminal in raw mode to watch for Esc, which clears ONLCR — so anything
+        # printed inside it staircases down the screen. Everywhere else it wraps
+        # only the provider HTTP call, where nothing prints; a sub-agent run prints
+        # throughout. Ctrl-C still lands here as an Interrupt.
+        result = sub.run
+      rescue Interrupt
+        @channel.display_warning("  Cancelled.")
+        log_interactive_turn(status: 'ready')
+        return
+      end
+
+      record_sub_agent_usage(sub)
+
+      @history << {
+        role: :user,
+        content: "The user ran the \"#{agent['name']}\" agent with the task: #{task}\n\n" \
+                 "The agent reported back:\n#{result}"
+      }
+
+      @channel.display(result.to_s)
+      log_interactive_turn(status: 'ready')
+    end
+
     def execute_direct(raw_code)
       @interactive_query ||= "> #{raw_code}"
       log_interactive_turn(status: 'running')
@@ -424,6 +512,7 @@ module RailsConsoleAi
       end
 
       total_cost = 0.0
+      has_reported_cost = false
       $stdout.puts "\e[36m  Cost estimate:\e[0m"
 
       @token_usage.each do |model, usage|
@@ -432,13 +521,25 @@ module RailsConsoleAi
         input_str = "in: #{format_tokens(usage[:input])}"
         output_str = "out: #{format_tokens(usage[:output])}"
 
-        if pricing
+        # A provider that reports real dollars (OpenRouter) beats any estimate.
+        reported_cost = usage[:cost]
+        if reported_cost && reported_cost > 0
+          has_reported_cost = true
+          total_cost += reported_cost
+          cache_str = ""
           cache_read = usage[:cache_read] || 0
           cache_write = usage[:cache_write] || 0
-          cost = usage_cost(pricing, input: usage[:input], output: usage[:output],
-                                     cache_read: cache_read, cache_write: cache_write)
+          cache_str = "  cache r: #{format_tokens(cache_read)} w: #{format_tokens(cache_write)}" if cache_read > 0 || cache_write > 0
+          $stdout.puts "\e[2m    #{model}:  #{input_str}  #{output_str}#{cache_str}  $#{'%.4f' % reported_cost}\e[0m"
+        elsif pricing
+          cost = Configuration.estimate_cost(model,
+            input: usage[:input], output: usage[:output],
+            cache_read: usage[:cache_read] || 0, cache_write: usage[:cache_write] || 0,
+            cache_ttl: RailsConsoleAi.configuration.resolved_cache_ttl)
           total_cost += cost
           cache_str = ""
+          cache_read = usage[:cache_read] || 0
+          cache_write = usage[:cache_write] || 0
           cache_str = "  cache r: #{format_tokens(cache_read)} w: #{format_tokens(cache_write)}" if cache_read > 0 || cache_write > 0
           $stdout.puts "\e[2m    #{model}:  #{input_str}  #{output_str}#{cache_str}  ~$#{'%.2f' % cost}\e[0m"
         else
@@ -446,7 +547,8 @@ module RailsConsoleAi
         end
       end
 
-      $stdout.puts "\e[36m    Total: ~$#{'%.2f' % total_cost}\e[0m"
+      label = has_reported_cost ? "Total:" : "Total: ~"
+      $stdout.puts "\e[36m    #{label}$#{'%.2f' % total_cost}\e[0m"
     end
 
     def display_conversation
@@ -505,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
 
-      if current == default && @model_override.nil?
-        $stdout.puts "\e[36m  Already using default model (#{current}).\e[0m"
+    def switch_model_tier(tier)
+      raise ArgumentError, "Unknown model tier: #{tier.inspect}" unless MODEL_TIERS.include?(tier)
+
+      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
@@ -653,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
 
@@ -695,6 +818,19 @@ module RailsConsoleAi
 
     private
 
+    def record_sub_agent_usage(sub)
+      absorb_sub_agent_usage(input: sub.input_tokens, output: sub.output_tokens, model: sub.model_used, cost: sub.cost)
+    end
+
+    def absorb_sub_agent_usage(usage)
+      @total_input_tokens += usage[:input] || 0
+      @total_output_tokens += usage[:output] || 0
+      return unless usage[:model]
+      @token_usage[usage[:model]][:input] += usage[:input] || 0
+      @token_usage[usage[:model]][:output] += usage[:output] || 0
+      @token_usage[usage[:model]][:cost] = (@token_usage[usage[:model]][:cost] || 0) + usage[:cost] if usage[:cost]
+    end
+
     def safety_context
       guards = RailsConsoleAi.configuration.safety_guards
       return nil if guards.empty?
@@ -750,16 +886,24 @@ module RailsConsoleAi
 
     def provider
       @provider ||= begin
-        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
@@ -880,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
@@ -939,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
@@ -994,13 +1167,7 @@ module RailsConsoleAi
 
           # Aggregate sub-agent token usage into parent's cost tracking
           if tc[:name] == 'delegate_task' && tools.last_sub_agent_usage
-            sa = tools.last_sub_agent_usage
-            @total_input_tokens += sa[:input] || 0
-            @total_output_tokens += sa[:output] || 0
-            if sa[:model]
-              @token_usage[sa[:model]][:input] += sa[:input] || 0
-              @token_usage[sa[:model]][:output] += sa[:output] || 0
-            end
+            absorb_sub_agent_usage(tools.last_sub_agent_usage)
           end
 
           if RailsConsoleAi.configuration.debug
@@ -1109,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
@@ -1134,6 +1304,7 @@ module RailsConsoleAi
       @token_usage[model][:output] += result.output_tokens || 0
       @token_usage[model][:cache_read] = (@token_usage[model][:cache_read] || 0) + (result.cache_read_input_tokens || 0)
       @token_usage[model][:cache_write] = (@token_usage[model][:cache_write] || 0) + (result.cache_write_input_tokens || 0)
+      @token_usage[model][:cost] = (@token_usage[model][:cost] || 0) + (result.cost || 0) if result.cost
     end
 
     def display_usage(result, show_session: false)
@@ -1196,18 +1367,6 @@ 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"
@@ -1559,13 +1718,17 @@ module RailsConsoleAi
       cache_r = result.cache_read_input_tokens || 0
       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, cache_ttl: RailsConsoleAi.configuration.resolved_cache_ttl)
-      if pricing
-        cost = usage_cost(pricing, input: result.input_tokens, output: result.output_tokens,
-                                   cache_read: cache_r, cache_write: cache_w)
-        parts << "~$#{'%.4f' % cost}"
+
+      if result.cost
+        parts << "$#{'%.4f' % result.cost}"
+      else
+        cost = Configuration.estimate_cost(effective_model,
+          input: result.input_tokens || 0, output: result.output_tokens || 0,
+          cache_read: cache_r, cache_write: cache_w,
+          cache_ttl: RailsConsoleAi.configuration.resolved_cache_ttl)
+        parts << "~$#{'%.4f' % cost}" if cost
       end
+
       parts.join(' | ')
     end
 
@@ -1597,11 +1760,18 @@ module RailsConsoleAi
       parts = ["in: #{format_tokens(input_t)}", "out: #{format_tokens(output_t)}"]
       parts << "cache r: #{format_tokens(cache_r)} w: #{format_tokens(cache_w)}" if cache_r > 0 || cache_w > 0
 
-      if pricing
-        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}"
+      ttl = RailsConsoleAi.configuration.resolved_cache_ttl
+      if result.cost
+        parts << "$#{'%.4f' % result.cost}"
+        session_has_reported = @token_usage.any? { |_, u| u[:cost] && u[:cost] > 0 }
+        session_cost = session_has_reported ? @token_usage.sum { |_, u| u[:cost] || 0 } :
+          Configuration.estimate_cost(model, input: total_input, output: total_output, cache_ttl: ttl) || 0
+        $stderr.puts "\n#{d}[debug]   ← response: #{parts.join(' | ')}  (session: $#{'%.4f' % session_cost})#{r}"
+      elsif pricing
+        cost = Configuration.estimate_cost(model, input: input_t, output: output_t,
+          cache_read: cache_r, cache_write: cache_w, cache_ttl: ttl)
+        parts << "~$#{'%.4f' % cost}" if cost
+        session_cost = Configuration.estimate_cost(model, input: total_input, output: total_output, cache_ttl: ttl) || 0
         $stderr.puts "\n#{d}[debug]   ← response: #{parts.join(' | ')}  (session: ~$#{'%.4f' % session_cost})#{r}"
       else
         $stderr.puts "\n#{d}[debug]   ← response: #{parts.join(' | ')}#{r}"

data/lib/rails_console_ai/line_editor.rb

@@ -0,0 +1,142 @@
+module RailsConsoleAi
+  # Thin adapters over the two line editors we can drive, so the interactive loop
+  # doesn't care which one is underneath.
+  #
+  # Reline (bundled with Ruby >= 2.7) is preferred: it renders a live completion
+  # dropdown as you type, which is what makes "/" discoverable. Readline is the
+  # fallback and only offers Tab completion.
+  #
+  # The two differ in four ways that matter here, all absorbed by the adapters:
+  #   - prompt escaping: Readline needs \001..\002 around ANSI so it can compute
+  #     the prompt width; Reline parses ANSI itself and would print those literally.
+  #   - output: Reline writes through a Ruby IO, so it has to be pointed at the real
+  #     stdout — otherwise the dropdown's escape codes land in the captured session log.
+  #     Readline writes to its own C-level stream and bypasses $stdout entirely.
+  #   - key binding: Readline has parse_and_bind, Reline has add_default_key_binding.
+  #   - what a completion candidate may contain: see #matches in each adapter.
+  module LineEditor
+    # Shift-Tab: jump to line start, kill the line, type /auto, submit.
+    # Reline binds real bytes; Readline's inputrc parser wants the escapes
+    # un-interpreted, so it gets the backslash form verbatim.
+    SHIFT_TAB   = "\e[Z".freeze
+    AUTO_MACRO  = "\C-a\C-k/auto\C-m".freeze
+    INPUTRC_BIND = '"\e[Z": "\C-a\C-k/auto\C-m"'.freeze
+
+    def self.resolve(preference = nil, output: nil)
+      preference = (preference || :auto).to_sym
+      editor =
+        case preference
+        when :readline then readline_adapter
+        when :reline   then reline_adapter || readline_adapter
+        else reline_adapter || readline_adapter
+        end
+      editor.output = output if output && editor.respond_to?(:output=)
+      editor
+    end
+
+    def self.reline_adapter
+      require 'reline'
+      Reline.respond_to?(:autocompletion=) ? Reline_.new : nil
+    rescue LoadError
+      nil
+    end
+
+    def self.readline_adapter
+      require 'readline'
+      Readline_.new
+    end
+
+    class Base
+      def name; self.class.name.split('::').last.chomp('_').downcase; end
+
+      # Candidates come from a proc so the list stays live — skills and agents can
+      # be created mid-session. The proc returns [slug, label] pairs, where the
+      # label says what kind of thing the slug is ("command", "skill", "agent").
+      def complete_with(&candidates); @candidates = candidates; self; end
+
+      def matches(target)
+        matching(target).map(&:first)
+      end
+
+      private
+
+      def matching(target)
+        return [] unless target.to_s.start_with?('/')
+        entries = @candidates ? @candidates.call : []
+        entries.select { |slug, _| slug.start_with?(target) }
+      end
+    end
+
+    class Reline_ < Base
+      def initialize
+        Reline.autocompletion = true
+        Reline.completion_append_character = ' '
+        Reline.completion_proc = ->(target) { matches(target) }
+      end
+
+      def output=(io); Reline.output = io; end
+
+      def prompt(text, color)
+        "#{color}#{text}\e[0m"
+      end
+
+      def readline(prompt)
+        Reline.readline(prompt, false)
+      end
+
+      def push_history(line)
+        Reline::HISTORY.push(line) unless line == Reline::HISTORY.to_a.last
+      end
+
+      def bind_auto_toggle
+        Reline.core.config.add_default_key_binding(SHIFT_TAB.bytes, AUTO_MACRO.bytes)
+      rescue StandardError
+        nil
+      end
+
+      # Reline's menu inserts whichever row you arrow onto, verbatim, so a
+      # candidate has to be exactly the text that belongs in the buffer. No labels.
+    end
+
+    class Readline_ < Base
+      def initialize
+        Readline.completion_append_character = ' '
+        Readline.completion_proc = ->(target) { matches(target) }
+      end
+
+      def prompt(text, color)
+        "\001#{color}\002#{text}\001\e[0m\002"
+      end
+
+      def readline(prompt)
+        Readline.readline(prompt, false)
+      end
+
+      def push_history(line)
+        Readline::HISTORY.push(line) unless line == Readline::HISTORY.to_a.last
+      end
+
+      def bind_auto_toggle
+        return unless Readline.respond_to?(:parse_and_bind)
+        Readline.parse_and_bind(INPUTRC_BIND)
+      end
+
+      # Readline only ever inserts the common prefix of the candidates it is given,
+      # and displays the rest for the eye alone — so when there is more than one
+      # match we can append a kind label without it ever reaching the buffer. That
+      # is what makes a built-in command distinguishable from a skill or an agent
+      # in the Tab list. The labels sit past the point where the slugs diverge, so
+      # they can't lengthen the common prefix either.
+      #
+      # A lone match is different: there the common prefix IS the whole candidate,
+      # so it must be the bare slug, and Readline appends its trailing space.
+      def matches(target)
+        found = matching(target)
+        return found.map(&:first) if found.size <= 1
+
+        width = found.map { |slug, _| slug.length }.max + 2
+        found.map { |slug, label| "#{slug.ljust(width)}#{label}" }
+      end
+    end
+  end
+end

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

@@ -5,6 +5,7 @@ module RailsConsoleAi
   module Providers
     class Base
       attr_reader :config
+      attr_accessor :routing_session_id
 
       def initialize(config = RailsConsoleAi.configuration)
         @config = config
@@ -28,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
@@ -150,7 +165,7 @@ module RailsConsoleAi
     class ProviderError < StandardError; end
 
     ChatResult = Struct.new(:text, :input_tokens, :output_tokens, :tool_calls, :stop_reason,
-                            :cache_read_input_tokens, :cache_write_input_tokens, keyword_init: true) do
+                            :cache_read_input_tokens, :cache_write_input_tokens, :cost, keyword_init: true) do
       def total_tokens
         (input_tokens || 0) + (output_tokens || 0)
       end
@@ -158,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)
@@ -168,6 +189,10 @@ module RailsConsoleAi
       when :openai
         require 'rails_console_ai/providers/openai'
         OpenAI.new(config)
+      when :openrouter
+        require 'rails_console_ai/providers/openai'
+        require 'rails_console_ai/providers/openrouter'
+        OpenRouter.new(config)
       when :local
         require 'rails_console_ai/providers/openai'
         require 'rails_console_ai/providers/local'