rails_console_ai 0.34.0 → 0.36.0

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

@@ -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

@@ -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,17 +29,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
 
@@ -85,7 +151,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
@@ -103,6 +169,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'

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/local.rb

@@ -3,38 +3,19 @@ module RailsConsoleAi
     class Local < OpenAI
       private
 
-      def call_api(messages, system_prompt: nil, tools: nil)
-        base_url = config.local_url
-
-        headers = { 'Content-Type' => 'application/json' }
-        api_key = config.local_api_key
-        if api_key && api_key != 'no-key' && !api_key.empty?
-          headers['Authorization'] = "Bearer #{api_key}"
-        end
-
-        conn = build_connection(base_url, headers)
-
-        formatted = []
-        formatted << { role: 'system', content: system_prompt } if system_prompt
-        formatted.concat(format_messages(messages))
-
-        body = {
-          model: config.resolved_model,
-          max_tokens: config.resolved_max_tokens,
-          messages: formatted
-        }
-        temp = config.resolved_temperature
-        body[:temperature] = temp unless temp.nil?
-        body[:tools] = tools.to_openai_format if tools
+      def api_base
+        config.local_url
+      end
 
-        estimated_input_tokens = estimate_tokens(formatted, system_prompt, tools)
+      def request_headers
+        key = config.local_api_key
+        return {} if key.nil? || key.empty? || key == 'no-key'
+        { 'Authorization' => "Bearer #{key}" }
+      end
 
-        json_body = JSON.generate(body)
-        debug_request("#{base_url}/v1/chat/completions", body)
-        response = conn.post('/v1/chat/completions', json_body)
-        debug_response(response.body)
-        data = parse_response(response)
+      def build_result(data, body:, tools: nil)
         usage = data['usage'] || {}
+        estimated_input_tokens = estimate_tokens(body)
 
         prompt_tokens = usage['prompt_tokens']
         if prompt_tokens && estimated_input_tokens > 0 && prompt_tokens < estimated_input_tokens * 0.5
@@ -50,9 +31,6 @@ module RailsConsoleAi
 
         tool_calls = extract_tool_calls(message)
 
-        # Fallback: some local models (e.g. Ollama) emit tool calls as JSON
-        # in the content field instead of using the structured tool_calls format.
-        # Only match when the JSON "name" is a known tool name to avoid false positives.
         if tool_calls.empty? && tools
           tool_names = tools.to_openai_format.map { |t| t.dig('function', 'name') }.compact
           text_calls = extract_tool_calls_from_text(message['content'], tool_names)
@@ -74,10 +52,12 @@ module RailsConsoleAi
         )
       end
 
-      def estimate_tokens(messages, system_prompt, tools)
-        chars = system_prompt.to_s.length
-        messages.each { |m| chars += m[:content].to_s.length + (m[:tool_calls].to_s.length) }
-        chars += tools.to_openai_format.to_s.length if tools
+      def estimate_tokens(body)
+        chars = 0
+        (body[:messages] || []).each do |m|
+          chars += m[:content].to_s.length + (m[:tool_calls].to_s.length)
+        end
+        chars += body[:tools].to_s.length if body[:tools]
         chars / 4
       end
 

data/lib/rails_console_ai/providers/openai.rb

@@ -40,12 +40,35 @@ module RailsConsoleAi
       private
 
       def call_api(messages, system_prompt: nil, tools: nil)
-        conn = build_connection(API_URL, {
-          'Authorization' => "Bearer #{config.resolved_api_key}"
-        })
+        conn = build_connection(api_base, request_headers)
+        body = build_body(messages, system_prompt: system_prompt, tools: tools)
+        debug_request("#{api_base}#{endpoint_path}", body)
+        response = with_retries { conn.post(endpoint_path, JSON.generate(body)) }
+        debug_response(response.body)
+        build_result(parse_response(response), body: body, tools: tools)
+      end
+
+      def api_base
+        API_URL
+      end
+
+      def endpoint_path
+        '/v1/chat/completions'
+      end
 
+      def request_headers
+        { 'Authorization' => "Bearer #{config.resolved_api_key}" }
+      end
+
+      # Overridable: providers that support explicit cache breakpoints emit
+      # multipart content here instead of a bare string.
+      def system_message(system_prompt)
+        { role: 'system', content: system_prompt }
+      end
+
+      def build_body(messages, system_prompt:, tools:)
         formatted = []
-        formatted << { role: 'system', content: system_prompt } if system_prompt
+        formatted << system_message(system_prompt) if system_prompt
         formatted.concat(format_messages(messages))
 
         body = {
@@ -56,12 +79,10 @@ module RailsConsoleAi
         temp = config.resolved_temperature
         body[:temperature] = temp unless temp.nil?
         body[:tools] = tools.to_openai_format if tools
+        body
+      end
 
-        json_body = JSON.generate(body)
-        debug_request("#{API_URL}/v1/chat/completions", body)
-        response = conn.post('/v1/chat/completions', json_body)
-        debug_response(response.body)
-        data = parse_response(response)
+      def build_result(data, body:, tools: nil)
         usage = data['usage'] || {}
 
         choice = (data['choices'] || []).first || {}

data/lib/rails_console_ai/providers/openrouter.rb

@@ -0,0 +1,100 @@
+module RailsConsoleAi
+  module Providers
+    class OpenRouter < OpenAI
+      DEFAULT_URL = 'https://openrouter.ai'.freeze
+      ANTHROPIC_MODEL = /anthropic\/|claude/i
+
+      private
+
+      def api_base
+        config.openrouter_url || DEFAULT_URL
+      end
+
+      def endpoint_path
+        '/api/v1/chat/completions'
+      end
+
+      def request_headers
+        h = { 'Authorization' => "Bearer #{config.resolved_api_key}" }
+        h['HTTP-Referer'] = config.openrouter_site_url if config.openrouter_site_url
+        h['X-Title'] = config.openrouter_app_name if config.openrouter_app_name
+        h
+      end
+
+      def build_body(messages, system_prompt:, tools:)
+        body = super
+        # Root-level cache_control is OpenRouter's automatic mode: it places a
+        # breakpoint on the last cacheable block and moves it forward as the
+        # conversation grows, which is what a tool loop needs — otherwise every
+        # round re-bills the whole accumulated history at full input price.
+        body[:cache_control] = cache_control if cache_supported?
+        body[:session_id] = routing_session_id if routing_session_id
+        # OpenRouter only returns usage.cost — the real dollars every cost
+        # readout prefers over an estimate — when the request asks for it.
+        body[:usage] = { include: true }
+        body
+      end
+
+      # The static system prefix gets its own explicit breakpoint so it has a
+      # guaranteed read point no matter what happens later in `messages`; the
+      # automatic breakpoint above then covers the growing tail. OpenRouter
+      # expresses Anthropic breakpoints as OpenAI-style multipart content.
+      def system_message(system_prompt)
+        return super unless cache_supported?
+
+        { role: 'system',
+          content: [{ type: 'text', text: system_prompt, cache_control: cache_control }] }
+      end
+
+      # Same TTL on every breakpoint: entries with the longer TTL must precede
+      # shorter ones, and an explicit marker whose TTL differs from the root-level
+      # field's is rejected outright.
+      def cache_control
+        ttl = config.respond_to?(:resolved_cache_ttl) ? config.resolved_cache_ttl : nil
+        ttl ? { type: 'ephemeral', ttl: ttl } : { type: 'ephemeral' }
+      end
+
+      def build_result(data, body:, tools: nil)
+        raise_inline_error!(data)
+        result = super
+        usage = data['usage'] || {}
+        details = usage['prompt_tokens_details'] || {}
+
+        cache_read = details['cached_tokens'].to_i
+        cache_write = details['cache_write_tokens'].to_i
+        result.cache_read_input_tokens = cache_read
+        result.cache_write_input_tokens = cache_write
+        result.cost = usage['cost']
+
+        # OpenAI-shaped `prompt_tokens` is the WHOLE prompt, cached tokens
+        # included; Anthropic's `input_tokens` is the uncached remainder, and the
+        # engine is built on the Anthropic contract — it reconstructs total prompt
+        # volume as input + cache_read + cache_write for the runaway-loop budget
+        # breakers. Left as sent, a cached round counts twice and those breakers
+        # fire at half the volume they are set to.
+        if result.input_tokens
+          result.input_tokens = [result.input_tokens - cache_read - cache_write, 0].max
+        end
+
+        if result.tool_calls&.any?
+          result.stop_reason = :tool_use
+        end
+
+        result
+      end
+
+      def cache_supported?
+        config.resolved_model.to_s.match?(ANTHROPIC_MODEL)
+      end
+
+      def raise_inline_error!(data)
+        err = data['error'] || (data['choices'] || []).first&.dig('error')
+        return unless err
+
+        msg = err.is_a?(Hash) ? (err['message'] || err.to_s) : err.to_s
+        code = err.is_a?(Hash) ? err['code'] : 'unknown'
+        raise ProviderError, "OpenRouter error (#{code}): #{msg}"
+      end
+    end
+  end
+end

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)