rails_console_ai 0.34.0 → 0.36.0

data/lib/rails_console_ai/slack_bot.rb

@@ -737,23 +737,31 @@ module RailsConsoleAi
 
       lines = ["*Cost estimate:*"]
       total_cost = 0.0
+      has_reported_cost = false
 
       token_usage.each do |model, usage|
-        pricing = Configuration.pricing_for(model)
+        pricing = Configuration.pricing_for(model, cache_ttl: RailsConsoleAi.configuration.resolved_cache_ttl)
         pricing ||= { input: 0.0, output: 0.0 } if RailsConsoleAi.configuration.provider == :local
         input_str = "in: #{usage[:input]}"
         output_str = "out: #{usage[:output]}"
 
-        if pricing
-          cost = (usage[:input] * pricing[:input]) + (usage[:output] * pricing[:output])
+        reported_cost = usage[:cost]
+        if reported_cost && reported_cost > 0
+          has_reported_cost = true
+          total_cost += reported_cost
+          cache_read = usage[:cache_read] || 0
+          cache_write = usage[:cache_write] || 0
+          cache_str = ""
+          cache_str = "  cache r: #{cache_read} w: #{cache_write}" if cache_read > 0 || cache_write > 0
+          lines << "  `#{model}`: #{input_str}  #{output_str}#{cache_str}  $#{'%.4f' % reported_cost}"
+        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 if cost
           cache_read = usage[:cache_read] || 0
           cache_write = usage[:cache_write] || 0
-          if (cache_read > 0 || cache_write > 0) && pricing[:cache_read]
-            cost -= cache_read * pricing[:input]
-            cost += cache_read * pricing[:cache_read]
-            cost += cache_write * (pricing[:cache_write] - pricing[:input])
-          end
-          total_cost += cost
           cache_str = ""
           cache_str = "  cache r: #{cache_read} w: #{cache_write}" if cache_read > 0 || cache_write > 0
           lines << "  `#{model}`: #{input_str}  #{output_str}#{cache_str}  ~$#{'%.2f' % cost}"
@@ -762,7 +770,8 @@ module RailsConsoleAi
         end
       end
 
-      lines << "*Total: ~$#{'%.2f' % total_cost}*"
+      label = has_reported_cost ? "Total:" : "Total: ~"
+      lines << "*#{label}$#{'%.2f' % total_cost}*"
       lines.join("\n")
     end
 

data/lib/rails_console_ai/slash_commands.rb

@@ -0,0 +1,149 @@
+require 'rails_console_ai/skill_loader'
+require 'rails_console_ai/agent_loader'
+
+module RailsConsoleAi
+  # The union of everything a user can invoke by typing "/" in interactive mode:
+  # the fixed REPL commands, plus every activatable skill and agent, each exposed
+  # under a slug derived from its display name ("Restart user trial" -> /restart-user-trial).
+  #
+  # Backs three surfaces that must agree with each other: the "/" listing, the
+  # completion candidates offered by the line editor, and the dispatcher that
+  # decides what a typed slash command actually does.
+  class SlashCommands
+    Command = Struct.new(:slug, :name, :description, :kind, :record, keyword_init: true) do
+      def builtin?; kind == :builtin; end
+      def skill?;   kind == :skill;   end
+      def agent?;   kind == :agent;   end
+    end
+
+    KIND_LABELS = { builtin: 'command', skill: 'skill', agent: 'agent' }.freeze
+
+    # Slug => one-line help. Order is the order they render in the listing.
+    # Descriptions that depend on live state (auto-execute on/off, safe mode)
+    # are filled in by the channel at render time; these are the static fallbacks.
+    BUILTINS = {
+      'auto'    => 'Toggle auto-execute',
+      'danger'  => 'Toggle safe mode',
+      'safe'    => 'Show safety guard status',
+      'model'   => 'Show provider, model, and pricing info',
+      'think'   => 'Switch to thinking model',
+      'unthink' => 'Switch back to default model',
+      'compact' => 'Summarize conversation to reduce context',
+      'usage'   => 'Show session token totals',
+      'cost'    => 'Show cost estimate by model',
+      'name'    => 'Name this session for easy resume',
+      'context' => 'Show conversation history sent to the LLM',
+      'system'  => 'Show the system prompt',
+      'expand'  => 'Show full omitted output',
+      'debug'   => 'Toggle debug summaries',
+      'retry'   => 'Re-execute the last code block'
+    }.freeze
+
+    # "Restart user trial" -> restart-user-trial.
+    #
+    # Close to SkillLoader#skill_key / AgentLoader#agent_key, but kinder to names
+    # that aren't plain prose: those two drop "/" and case boundaries outright,
+    # which turns "Approve/Reject ChangeApprovals" into the unreadable
+    # "approvereject-changeapprovals". Here every boundary a human would read as
+    # a word break becomes a dash. The slug is only ever a handle for typing and
+    # dispatch — file lookup still goes through the loaders — so the two are free
+    # to differ.
+    def self.slugify(name)
+      name.to_s.strip
+        .gsub(%r{[/_\s]+}, '-')                       # separators
+        .gsub(/([a-z0-9])([A-Z])/, '\1-\2')           # fooBar    -> foo-Bar
+        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1-\2')        # HTTPToken -> HTTP-Token
+        .downcase
+        .gsub(/[^a-z0-9-]/, '')
+        .gsub(/-+/, '-')
+        .sub(/\A-/, '').sub(/-\z/, '')
+    end
+
+    def initialize(skill_loader: nil, agent_loader: nil)
+      @skill_loader = skill_loader
+      @agent_loader = agent_loader
+    end
+
+    # Loading skills and agents touches the DB and the filesystem, and completion
+    # runs on every keystroke — so the list is built once and reused until something
+    # that could have changed it (a save_skill/save_agent tool call) finishes.
+    def refresh!
+      @commands = nil
+      self
+    end
+
+    def commands
+      @commands ||= build
+    end
+
+    def skills
+      commands.select(&:skill?)
+    end
+
+    def agents
+      commands.select(&:agent?)
+    end
+
+    # Completion candidates, already "/"-prefixed.
+    def candidates
+      commands.map { |c| "/#{c.slug}" }
+    end
+
+    # [slug, kind label] pairs for the line editor. The label is what lets a Tab
+    # list say which entries are built-in commands and which are skills or agents.
+    def completion_entries
+      commands.map { |c| ["/#{c.slug}", KIND_LABELS[c.kind]] }
+    end
+
+    def find(slug)
+      slug = slug.to_s.sub(%r{\A/}, '').downcase
+      commands.find { |c| c.slug == slug }
+    end
+
+    private
+
+    def build
+      builtins = BUILTINS.map do |slug, desc|
+        Command.new(slug: slug, name: slug, description: desc, kind: :builtin, record: nil)
+      end
+
+      taken = builtins.map(&:slug)
+
+      skills = safe(:skills) do
+        skill_loader.load_activatable_skills.filter_map do |s|
+          slug = self.class.slugify(s['name'])
+          next if slug.empty? || taken.include?(slug)
+          taken << slug
+          Command.new(slug: slug, name: s['name'], description: s['description'], kind: :skill, record: s)
+        end
+      end
+
+      agents = safe(:agents) do
+        agent_loader.load_activatable_agents.filter_map do |a|
+          slug = self.class.slugify(a['name'])
+          next if slug.empty? || taken.include?(slug)
+          taken << slug
+          Command.new(slug: slug, name: a['name'], description: a['description'], kind: :agent, record: a)
+        end
+      end
+
+      builtins + skills.sort_by(&:slug) + agents.sort_by(&:slug)
+    end
+
+    # A broken skill file or an unmigrated database must not take down the prompt.
+    def safe(what)
+      yield
+    rescue => e
+      RailsConsoleAi.logger.warn("RailsConsoleAi: failed to load #{what} for slash commands: #{e.message}")
+      []
+    end
+
+    def skill_loader
+      @skill_loader ||= SkillLoader.new
+    end
+
+    def agent_loader
+      @agent_loader ||= AgentLoader.new
+    end
+  end
+end

data/lib/rails_console_ai/sub_agent.rb

@@ -10,7 +10,7 @@ module RailsConsoleAi
     LARGE_OUTPUT_THRESHOLD = 10_000
     LARGE_OUTPUT_PREVIEW_CHARS = 8_000
 
-    attr_reader :input_tokens, :output_tokens, :model_used
+    attr_reader :input_tokens, :output_tokens, :model_used, :cost
 
     def initialize(task:, agent_config:, binding_context:, parent_channel:, executor:,
                    output_payload: nil, output_local_name: :output)
@@ -23,6 +23,7 @@ module RailsConsoleAi
       @output_local_name = output_local_name
       @input_tokens = 0
       @output_tokens = 0
+      @cost = 0
       @model_used = nil
     end
 
@@ -83,6 +84,7 @@ module RailsConsoleAi
         end
         @input_tokens += result.input_tokens || 0
         @output_tokens += result.output_tokens || 0
+        @cost += result.cost || 0
 
         break if channel.cancelled?
         break unless result.tool_use?
@@ -144,13 +146,19 @@ module RailsConsoleAi
       end
 
       if exhausted
-        messages << { role: :user, content: "Provide your best answer now based on what you've learned." }
-        result = provider.chat(messages, system_prompt: system_prompt)
+        messages << { role: :user, content: "Provide your best answer now based on what you've learned. Do not call any more tools." }
+        # Must be chat_with_tools, not chat: the transcript contains
+        # tool_use/tool_result blocks, and Bedrock/Anthropic reject those unless
+        # the request also defines tools. Any tool calls in the response are
+        # ignored — only the text is used.
+        result = provider.chat_with_tools(messages, tools: tools, system_prompt: system_prompt)
         @input_tokens += result.input_tokens || 0
         @output_tokens += result.output_tokens || 0
+        @cost += result.cost || 0
       end
 
-      result&.text || '(sub-agent returned no result)'
+      text = result&.text.to_s
+      text.strip.empty? ? '(sub-agent returned no result)' : text
     end
 
     def format_user_interruption(messages)
@@ -176,7 +184,7 @@ module RailsConsoleAi
       config = RailsConsoleAi.configuration
       model_override = @agent_config['model'] || config.sub_agent_model
 
-      if model_override
+      p = if model_override
         config_dup = config.dup
         config_dup.model = model_override
         @model_used = model_override
@@ -185,6 +193,8 @@ module RailsConsoleAi
         @model_used = config.resolved_model
         Providers.build(config)
       end
+      p.routing_session_id = SecureRandom.hex(8) if p.respond_to?(:routing_session_id=)
+      p
     end
 
     def build_system_prompt

data/lib/rails_console_ai/tools/registry.rb

@@ -381,7 +381,7 @@ module RailsConsoleAi
         # the live database. Scoped via thread-local (explore_output runs synchronously),
         # so the parent session's guard state is untouched.
         result = RailsConsoleAi.configuration.safety_guards.with_database_blocked { sub.run }
-        @last_sub_agent_usage = { input: sub.input_tokens, output: sub.output_tokens, model: sub.model_used }
+        @last_sub_agent_usage = { input: sub.input_tokens, output: sub.output_tokens, model: sub.model_used, cost: sub.cost }
         "Exploration result (#{sub.input_tokens + sub.output_tokens} tokens used, #{payload.length} chars explored):\n#{result}"
       end
 
@@ -418,7 +418,7 @@ module RailsConsoleAi
           executor: @executor
         )
         result = sub.run
-        @last_sub_agent_usage = { input: sub.input_tokens, output: sub.output_tokens, model: sub.model_used }
+        @last_sub_agent_usage = { input: sub.input_tokens, output: sub.output_tokens, model: sub.model_used, cost: sub.cost }
         "Sub-agent result (#{sub.input_tokens + sub.output_tokens} tokens used):\n#{result}"
       end
 

data/lib/rails_console_ai/version.rb

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

data/lib/rails_console_ai.rb

@@ -125,6 +125,7 @@ module RailsConsoleAi
       lines << "  Model:          #{c.resolved_model}"
       lines << "  API key:        #{masked_key}"
       lines << "  Local URL:      #{c.local_url}" if c.provider == :local
+      lines << "  OpenRouter URL: #{c.openrouter_url}" if c.openrouter_url
       lines << "  Max tokens:     #{c.max_tokens || '(auto)'}"
       lines << "  Temperature:    #{c.temperature}"
       lines << "  Timeout:        #{c.timeout}s"
@@ -154,6 +155,8 @@ module RailsConsoleAi
           t.text    :conversation,  null: false
           t.integer :input_tokens,  default: 0
           t.integer :output_tokens, default: 0
+          t.integer :cache_read_tokens,  default: 0
+          t.integer :cache_write_tokens, default: 0
           t.string  :user_name,     limit: 255
           t.string  :mode,          limit: 20, null: false
           t.text    :code_executed
@@ -397,6 +400,18 @@ module RailsConsoleAi
         migrations << 'options'
       end
 
+      # Without these, a session row records only the UNCACHED remainder of its
+      # input and the admin cost column reads near-zero for every cached session.
+      unless conn.column_exists?(table, :cache_read_tokens)
+        conn.add_column(table, :cache_read_tokens, :integer, default: 0)
+        migrations << 'cache_read_tokens'
+      end
+
+      unless conn.column_exists?(table, :cache_write_tokens)
+        conn.add_column(table, :cache_write_tokens, :integer, default: 0)
+        migrations << 'cache_write_tokens'
+      end
+
       unless conn.index_exists?(table, [:mode, :status], name: 'idx_rca_sessions_mode_status')
         conn.add_index(table, [:mode, :status], name: 'idx_rca_sessions_mode_status')
         migrations << 'idx_rca_sessions_mode_status'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_console_ai
 version: !ruby/object:Gem::Version
-  version: 0.34.0
+  version: 0.36.0
 platform: ruby
 authors:
 - Cortfr
@@ -166,18 +166,21 @@ files:
 - lib/rails_console_ai/conversation_engine.rb
 - lib/rails_console_ai/engine.rb
 - lib/rails_console_ai/executor.rb
+- lib/rails_console_ai/line_editor.rb
 - lib/rails_console_ai/prefixed_io.rb
 - lib/rails_console_ai/providers/anthropic.rb
 - lib/rails_console_ai/providers/base.rb
 - lib/rails_console_ai/providers/bedrock.rb
 - lib/rails_console_ai/providers/local.rb
 - lib/rails_console_ai/providers/openai.rb
+- lib/rails_console_ai/providers/openrouter.rb
 - lib/rails_console_ai/railtie.rb
 - lib/rails_console_ai/repl.rb
 - lib/rails_console_ai/safety_guards.rb
 - lib/rails_console_ai/session_logger.rb
 - lib/rails_console_ai/skill_loader.rb
 - lib/rails_console_ai/slack_bot.rb
+- lib/rails_console_ai/slash_commands.rb
 - lib/rails_console_ai/storage/base.rb
 - lib/rails_console_ai/storage/database_storage.rb
 - lib/rails_console_ai/storage/file_storage.rb