rails_console_ai 0.35.0 → 0.36.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37ef99b1cc4572e89283e5210b15e6110bac2b0adc758a1b7d222c603c4557c2
-  data.tar.gz: 511f76003fdc00ce0104b506eaa71d7de918e3cf1f62eebd395308461caeefd1
+  metadata.gz: ae704dc4b0f74645775e86661d9cb6d004df5c1e0b338ab012564d87317bff4c
+  data.tar.gz: 0f0f9c24eb4c7aad94175bde55c36571df238d3b067bbe124a49d341f7df0e03
 SHA512:
-  metadata.gz: e6cb2ccc4f03fbcafff6d7edcace1c80fd76a99692404f7e05aa039e9276665b07e03ab70b12043635b37742c5e05ffe1fa9fd42f77e25de6daff329c90e0dfc
-  data.tar.gz: ee6acd8f33f2d13c921832fd1d4470e9d08bd8a795ec45d7ebb3c7b67ae7ca3fb6475b46796192dcd4a0b2a48d66b0bbb8bc2b2e47e498e9785c12dad7eefba4
+  metadata.gz: 77f9088650c56287f17f4ef4e498537fdb6ddfc2a62b558085aa0cd717f02ddaa44379d427416bcc5b4ac2a6826105d361b1e9a25caacb400f25f60f369c4d43
+  data.tar.gz: 03f1b9c35af746872ac7ec9b9a4cfb5e630bcf66b006cef254501efdef0b4d04187be161fd544ffc52248cee85fe45a1ec3e01fc62f371db5c3a453b60705971

data/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.36.0]
+
+- Add an OpenRouter provider with access to 400+ models
+- Report exact costs when a provider returns them
+- Run any skill or agent as a slash command from the console
+- Add a live completion menu for slash commands
+- Support choosing between the Reline and Readline line editors
+- Fix cost reporting in the Slack bot
+
 ## [0.35.0]
 
 - Extend prompt caching to the full conversation history

data/README.md

@@ -88,6 +88,33 @@ end
 | `/system` | Show the system prompt |
 | `/name <label>` | Name the session for easy resume |
 
+#### Running skills and agents from the prompt
+
+Every skill and agent is also a slash command, under a slug built from its name —
+"Restart user trial" becomes `/restart-user-trial`. Type `/` and a menu of everything
+available appears as you type; press Enter on a bare `/` to print the full list.
+
+```
+ai> /restart-user-trial user 4821
+ai> /find-shard jess@example.com
+```
+
+The two behave differently on purpose:
+
+- **A skill runs here.** Its recipe is prepended to your request and its guard
+  bypasses are installed on the live executor, so the assistant follows the
+  procedure in the current conversation with full context.
+- **An agent runs elsewhere.** It gets its own context and tool loop, and only its
+  summary comes back into the conversation — the same isolation `delegate_task`
+  gives the model, now available to you directly. Its tokens are billed to the session.
+
+Anything after the command name is passed along as your request. A skill invoked
+bare (`/restart-user-trial`) just runs its procedure.
+
+Completion needs [Reline](https://github.com/ruby/reline), bundled with Ruby >= 2.7.
+Without it the gem falls back to Readline, where Tab completes instead of a live menu.
+Force one or the other with `c.line_editor = :reline` / `:readline` (default `:auto`).
+
 Prefix input with `>` to run Ruby directly (no LLM round-trip). The result is added to conversation context.
 
 Say "think harder" in any query to auto-upgrade to the thinking model for that session. After 5+ tool rounds, you'll also be prompted to switch.
@@ -282,7 +309,7 @@ Skills and global `bypass_guards_for_methods` coexist — use config-level bypas
 
 ## LLM Providers
 
-RailsConsoleAi supports four LLM providers. Each uses a two-tier model system: a default model for speed/cost, and a thinking model activated via `/think` or by saying "think harder".
+RailsConsoleAi supports five LLM providers. Each uses a two-tier model system: a default model for speed/cost, and a thinking model activated via `/think` or by saying "think harder".
 
 ### Anthropic (default)
 
@@ -306,6 +333,29 @@ end
 
 Default model: `gpt-5.3-codex`. OpenAI applies prompt caching automatically on their end for prompts over 1024 tokens.
 
+### OpenRouter
+
+Access 400+ models (Claude, GPT, Gemini, DeepSeek, Llama, etc.) via OpenRouter with unified OpenAI-compatible API. Automatic prompt caching for Anthropic models, real-time cost tracking, and provider sticky routing for cache hits.
+
+```ruby
+RailsConsoleAi.configure do |config|
+  config.provider = :openrouter
+  config.api_key = 'sk-or-...'  # or set OPENROUTER_API_KEY env var
+  # config.model = 'anthropic/claude-sonnet-5'  # default
+  # config.openrouter_site_url = 'https://yoursite.com'  # attribution
+  # config.openrouter_app_name = 'MyApp'                # shown on openrouter.ai
+end
+```
+
+Default model: `anthropic/claude-sonnet-5`. Thinking model: `anthropic/claude-opus-5`.
+
+**Features:**
+- **Exact cost reporting**: The gem reports the actual USD cost from OpenRouter (`$0.0431` vs estimated `~$0.04`)
+- **Automatic prompt caching**: Anthropic-family models (`anthropic/claude-*`) get a top-level `cache_control` breakpoint for multi-turn cache hits
+- **Sticky routing**: Session-based routing keeps requests on the same provider endpoint for cache warmth across the tool-use loop
+
+**Timeout note:** OpenRouter adds latency from request queueing and provider fallbacks. If you're routing to reasoning models, you may want to raise `config.timeout` above the 30s default.
+
 ### AWS Bedrock
 
 Access frontier models (Claude, Mistral, DeepSeek, Llama) via your AWS account with pay-per-token pricing. No API key needed — authentication uses the AWS SDK credential chain (IAM roles, env vars, `~/.aws/credentials`).
@@ -369,6 +419,9 @@ Before adopting a new Claude model, smoke-test it against the Anthropic or Bedro
 # Anthropic — provider inferred from the `claude-` prefix
 ANTHROPIC_API_KEY=sk-ant-... bin/smoke_model.rb --model claude-opus-4-8
 
+# OpenRouter — provider inferred from the `provider/model` format
+OPENROUTER_API_KEY=sk-or-... bin/smoke_model.rb --model anthropic/claude-opus-4
+
 # Bedrock — provider inferred from the regional `us.anthropic.` prefix.
 # Requires the aws-sdk-bedrockruntime gem and AWS credentials in the environment.
 bin/smoke_model.rb --model us.anthropic.claude-opus-4-8
@@ -391,13 +444,14 @@ Pricing, default max tokens, and parameter support (e.g. which families reject `
 
 ```ruby
 RailsConsoleAi.configure do |config|
-  config.provider = :anthropic       # :anthropic, :openai, :bedrock, :local
+  config.provider = :anthropic       # :anthropic, :openai, :openrouter, :bedrock, :local
   config.auto_execute = false         # true to skip confirmations
   config.session_logging = true       # requires ai_db_setup
   config.temperature = 0.2
   config.timeout = 30                 # HTTP timeout in seconds
   config.max_tool_rounds = 200        # safety cap on tool-use loops
   config.code_search_paths = %w[app]  # directories for list_files / search_code
+  config.line_editor = :auto          # :auto, :reline (live "/" menu), :readline
 
   # Runaway-loop circuit breakers (see "Runaway sessions" below)
   config.token_nudge_threshold = 500_000    # input tokens in one tool loop → nudge model to wrap up (nil disables)

data/app/helpers/rails_console_ai/sessions_helper.rb

@@ -1,17 +1,17 @@
 module RailsConsoleAi
   module SessionsHelper
-    # All four usage buckets bill at their own rate. `input_tokens` is the uncached
-    # remainder only — on a cached session it is a tiny fraction of the prompt, so
-    # pricing input+output alone reads as near-zero for the sessions that actually
-    # cost the most.
+    # The cache buckets have to be included: `input_tokens` is the uncached
+    # remainder only, so on a well-cached session pricing input+output alone reads
+    # as near-zero for exactly the sessions that cost the most.
     def estimated_cost(session)
-      pricing = Configuration.pricing_for(session.model)
-      return nil unless pricing
-
-      (session.input_tokens * pricing[:input]) +
-        (session.output_tokens * pricing[:output]) +
-        (session.try(:cache_read_tokens).to_i * pricing[:cache_read]) +
-        (session.try(:cache_write_tokens).to_i * pricing[:cache_write])
+      Configuration.estimate_cost(
+        session.model,
+        input: session.input_tokens,
+        output: session.output_tokens,
+        cache_read: session.try(:cache_read_tokens).to_i,
+        cache_write: session.try(:cache_write_tokens).to_i,
+        cache_ttl: RailsConsoleAi.configuration.resolved_cache_ttl
+      )
     end
 
     def format_cost(session)

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

@@ -1,5 +1,5 @@
 RailsConsoleAi.configure do |config|
-  # LLM provider: :anthropic, :openai, or :local
+  # LLM provider: :anthropic, :openai, :openrouter, :bedrock, or :local
   config.provider = :anthropic
 
   # API key (or set ANTHROPIC_API_KEY / OPENAI_API_KEY env var)
@@ -32,6 +32,12 @@ RailsConsoleAi.configure do |config|
   # config.local_model = 'qwen2.5:7b'
   # config.local_api_key = nil
 
+  # OpenRouter provider (400+ models via unified API):
+  # config.provider = :openrouter
+  # config.model = 'anthropic/claude-sonnet-5'
+  # config.openrouter_site_url = 'https://yoursite.com'  # optional, for attribution
+  # config.openrouter_app_name = 'MyApp'                # optional, shown on openrouter.ai
+
   # Slack: which users the bot responds to (legacy — prefer channels config below)
   # config.slack_allowed_usernames = ['alice', 'bob']
 

data/lib/rails_console_ai/channel/console.rb

@@ -1,5 +1,6 @@
-require 'readline'
 require 'rails_console_ai/channel/base'
+require 'rails_console_ai/line_editor'
+require 'rails_console_ai/slash_commands'
 
 module RailsConsoleAi
   module Channel
@@ -186,6 +187,16 @@ module RailsConsoleAi
         @interactive_console_capture = StringIO.new
         @real_stdout = $stdout
         $stdout = TeeIO.new(@real_stdout, @interactive_console_capture)
+        init_slash_commands
+      end
+
+      def init_slash_commands
+        @slash_commands = SlashCommands.new
+        # Point the editor at the real stdout: Reline draws its completion menu
+        # through a Ruby IO, and $stdout is a TeeIO right now — without this the
+        # menu's escape codes get written into the saved session log.
+        @editor = LineEditor.resolve(RailsConsoleAi.configuration.line_editor, output: @real_stdout)
+        @editor.complete_with { @slash_commands.completion_entries }
       end
 
       def run_interactive_loop
@@ -196,14 +207,13 @@ module RailsConsoleAi
         config = RailsConsoleAi.configuration
         @real_stdout.puts "\e[2m  Provider: #{config.provider} | Model: #{config.resolved_model}\e[0m"
         safe_info = guards.empty? ? '' : " | Safe mode: #{guards.enabled? ? 'ON' : 'OFF'} (/danger to toggle)"
-        @real_stdout.puts "\e[2m  Auto-execute: #{auto ? 'ON' : 'OFF'} (Shift-Tab or /auto to toggle)#{safe_info} | > code | /usage | /cost | /compact | /think | /name <label>\e[0m"
+        @real_stdout.puts "\e[2m  Auto-execute: #{auto ? 'ON' : 'OFF'} (Shift-Tab or /auto to toggle)#{safe_info} | > code\e[0m"
+        @real_stdout.puts "\e[2m  Type / for commands, skills and agents#{@editor.is_a?(LineEditor::Reline_) ? ' (menu appears as you type)' : ' (Tab to complete)'}\e[0m"
 
-        if Readline.respond_to?(:parse_and_bind)
-          Readline.parse_and_bind('"\e[Z": "\C-a\C-k/auto\C-m"')
-        end
+        @editor.bind_auto_toggle
 
         loop do
-          input = Readline.readline("\001\e[33m\002ai> \001\e[0m\002", false)
+          input = @editor.readline(@editor.prompt('ai> ', "\e[33m"))
           break if input.nil?
 
           input = input.strip
@@ -211,8 +221,13 @@ module RailsConsoleAi
           break if input.downcase == 'exit' || input.downcase == 'quit'
           next if input.empty?
 
-          handled = handle_slash_command(input)
-          next if handled
+          # What the user typed, kept for history/logging even when a skill
+          # command expands into a much longer prompt.
+          typed = input
+
+          outcome = handle_slash_command(input)
+          next if outcome == :handled
+          input = outcome if outcome.is_a?(String)
 
           # Direct code execution with ">" prefix
           if input.start_with?('>') && !input.start_with?('>=')
@@ -220,14 +235,13 @@ module RailsConsoleAi
             next
           end
 
-          # Add to Readline history
-          Readline::HISTORY.push(input) unless input == Readline::HISTORY.to_a.last
+          @editor.push_history(typed)
 
           @engine.maybe_auto_upgrade_thinking(input)
 
-          @engine.set_interactive_query(input)
+          @engine.set_interactive_query(typed)
           @engine.add_user_message(input)
-          @interactive_console_capture.write("ai> #{input}\n")
+          @interactive_console_capture.write("ai> #{typed}\n")
           @engine.log_interactive_turn
 
           expected_stdout = $stdout
@@ -254,6 +268,9 @@ module RailsConsoleAi
 
           @engine.log_interactive_turn
           @engine.warn_if_history_large
+          # A turn may have created a skill or agent via save_skill/save_agent —
+          # drop the memo so the next "/" reflects it.
+          @slash_commands.refresh!
         end
 
         $stdout = @real_stdout
@@ -269,6 +286,9 @@ module RailsConsoleAi
         $stderr.puts "\e[31mRailsConsoleAi Error: #{e.class}: #{e.message}\e[0m"
       end
 
+      # Returns :handled when the command did its own thing, a String when it
+      # should be sent to the model as this turn's message, or nil when the input
+      # isn't a slash command at all.
       def handle_slash_command(input)
         case input
         when '?', '/'
@@ -314,9 +334,47 @@ module RailsConsoleAi
         when /\A\/name/
           handle_name_command(input)
         else
-          return false
+          return dispatch_registry_command(input)
+        end
+        :handled
+      end
+
+      # Skills and agents are addressed by a slug derived from their name:
+      # "Restart user trial" -> /restart-user-trial.
+      def dispatch_registry_command(input)
+        return nil unless input.start_with?('/')
+
+        slug, _, args = input[1..].partition(/\s+/)
+        command = @slash_commands.find(slug)
+
+        unless command
+          # Only claim the input if it actually looks like a command. A message
+          # that merely opens with a path ("/tmp/foo.log has the error") must
+          # still reach the model untouched.
+          return nil unless slug =~ /\A[a-z0-9][a-z0-9_-]*\z/
+          warn_unknown_command(slug)
+          return :handled
+        end
+
+        case command.kind
+        when :skill
+          @engine.skill_command_prompt(command.record, args)
+        when :agent
+          @engine.run_agent_command(command.record, args)
+          :handled
+        else
+          nil # a built-in, already handled by the case above
+        end
+      end
+
+      def warn_unknown_command(slug)
+        @real_stdout.puts "\e[33m  Unknown command: /#{slug}\e[0m"
+        near = @slash_commands.candidates.select { |c| c.start_with?("/#{slug[0, 3]}") }
+        if near.empty?
+          @real_stdout.puts "\e[2m  Type / to see everything available.\e[0m"
+        else
+          @real_stdout.puts "\e[2m  Did you mean: #{near.first(5).join(', ')}?\e[0m"
         end
-        true
       end
 
       def retry_last_code
@@ -325,7 +383,7 @@ module RailsConsoleAi
 
       def handle_direct_execution(input)
         raw_code = input.sub(/\A>\s?/, '')
-        Readline::HISTORY.push(input) unless input == Readline::HISTORY.to_a.last
+        @editor.push_history(input)
         @interactive_console_capture.write("ai> #{input}\n")
         @engine.execute_direct(raw_code)
         @engine.log_interactive_turn
@@ -383,6 +441,7 @@ module RailsConsoleAi
         end
         @real_stdout.puts "\e[2m    Bedrock region:  #{config.bedrock_region}\e[0m" if config.provider == :bedrock
         @real_stdout.puts "\e[2m    Local URL:       #{config.local_url}\e[0m" if config.provider == :local
+        @real_stdout.puts "\e[2m    OpenRouter URL:  #{config.openrouter_url}\e[0m" if config.openrouter_url
       end
 
       def handle_name_command(input)
@@ -424,6 +483,52 @@ module RailsConsoleAi
         @real_stdout.puts "\e[2m    > code       Execute Ruby directly (skip LLM)\e[0m"
         @real_stdout.puts "\e[2m    Ctrl-C       Cancel the current operation\e[0m"
         @real_stdout.puts "\e[2m    exit/quit    Leave interactive mode\e[0m"
+        display_registry_help
+      end
+
+      # Skills and agents, listed the same way as the built-ins so "/" answers
+      # "what can I run?" in one place.
+      def display_registry_help
+        @slash_commands.refresh!
+
+        skills = @slash_commands.skills
+        agents = @slash_commands.agents
+        # Size the column to what's actually listed, and don't let one very long
+        # name push every description off the right edge.
+        width = [(skills + agents).map { |c| c.slug.length }.max.to_i + 2, 34].min
+
+        unless skills.empty?
+          @real_stdout.puts
+          @real_stdout.puts "\e[36m  Skills:\e[0m \e[2m(runs here, following the recipe)\e[0m"
+          skills.each { |c| @real_stdout.puts registry_help_row(c, width) }
+        end
+
+        unless agents.empty?
+          @real_stdout.puts
+          @real_stdout.puts "\e[36m  Agents:\e[0m \e[2m(runs in a separate context, reports back)\e[0m"
+          agents.each { |c| @real_stdout.puts registry_help_row(c, width) }
+        end
+
+        return if skills.empty? && agents.empty?
+        @real_stdout.puts
+        @real_stdout.puts "\e[2m  Pass a request after the name: /#{(skills.first || agents.first).slug} <what you want>\e[0m"
+      end
+
+      # One "/slug   description" line, clipped so a long description wraps into
+      # the next row instead of making the list unreadable.
+      def registry_help_row(command, width)
+        room = terminal_width - width - 6
+        desc = command.description.to_s
+        desc = "#{desc[0, room - 1]}\u2026" if room > 10 && desc.length > room
+        "\e[2m    /#{command.slug.ljust(width)} #{desc}\e[0m"
+      end
+
+      def terminal_width
+        require 'io/console'
+        cols = IO.console && IO.console.winsize.last.to_i
+        cols && cols > 40 ? cols : 100
+      rescue StandardError
+        100
       end
 
       def display_exit_info

data/lib/rails_console_ai/configuration.rb

@@ -1,6 +1,6 @@
 module RailsConsoleAi
   class Configuration
-    PROVIDERS = %i[anthropic openai local bedrock].freeze
+    PROVIDERS = %i[anthropic openai openrouter local bedrock].freeze
 
     # Per-family model attributes, matched by substring so one entry covers every
     # ID variant of a family: bare Anthropic IDs (claude-sonnet-5), dated
@@ -36,7 +36,8 @@ module RailsConsoleAi
     # Returns the family attributes for a model ID, or nil for unknown models.
     def self.model_family(model_id)
       return nil unless model_id
-      key = MODEL_FAMILY_KEYS.find { |k| model_id.include?(k) }
+      normalized = model_id.gsub(/(?<=\d)\.(?=\d)/, '-')
+      key = MODEL_FAMILY_KEYS.find { |k| normalized.include?(k) }
       key && MODEL_FAMILIES[key]
     end
 
@@ -56,6 +57,22 @@ module RailsConsoleAi
       }
     end
 
+    # The four usage buckets each bill at their own rate. The API's `input_tokens`
+    # 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 estimated cost readout goes through here. Providers that
+    # report real dollars (OpenRouter) are preferred over this estimate.
+    def self.estimate_cost(model, input:, output:, cache_read: 0, cache_write: 0, cache_ttl: nil)
+      pricing = pricing_for(model, cache_ttl: cache_ttl)
+      return nil unless pricing
+
+      ((input || 0) * pricing[:input]) +
+        ((output || 0) * pricing[:output]) +
+        ((cache_read || 0) * pricing[:cache_read]) +
+        ((cache_write || 0) * pricing[:cache_write])
+    end
+
     # Total context window for a model ID, matched by family.
     def self.context_window_for(model_id)
       family = model_family(model_id)
@@ -93,13 +110,15 @@ module RailsConsoleAi
                   :authenticate,
                   :slack_bot_token, :slack_app_token, :slack_channel_ids, :slack_allowed_usernames,
                   :local_url, :local_model, :local_api_key,
+                  :openrouter_url, :openrouter_app_name, :openrouter_site_url,
                   :bedrock_region,
                   :code_search_paths,
                   :channels,
                   :bypass_guards_for_methods,
                   :user_extra_info,
                   :sub_agent_max_rounds,
-                  :sub_agent_model
+                  :sub_agent_model,
+                  :line_editor
 
     def initialize
       @provider     = :anthropic
@@ -147,6 +166,9 @@ module RailsConsoleAi
       @local_url        = 'http://localhost:11434'
       @local_model      = 'qwen2.5:7b'
       @local_api_key    = nil
+      @openrouter_url   = nil
+      @openrouter_app_name = nil
+      @openrouter_site_url = nil
       @bedrock_region   = nil
       @code_search_paths = %w[app]
       @channels = {}
@@ -154,6 +176,9 @@ module RailsConsoleAi
       @user_extra_info = {}
       @sub_agent_max_rounds = 15
       @sub_agent_model = nil
+      # Interactive line editor: :auto prefers Reline (live "/" completion menu)
+      # and falls back to Readline. Force one with :reline or :readline.
+      @line_editor = :auto
     end
 
     def resolve_user_extra_info(username)
@@ -240,6 +265,8 @@ module RailsConsoleAi
         ENV['ANTHROPIC_API_KEY']
       when :openai
         ENV['OPENAI_API_KEY']
+      when :openrouter
+        ENV['OPENROUTER_API_KEY']
       when :local
         @local_api_key || 'no-key'
       when :bedrock
@@ -255,6 +282,8 @@ module RailsConsoleAi
         'claude-sonnet-5'
       when :openai
         'gpt-5.3-codex'
+      when :openrouter
+        'anthropic/claude-sonnet-5'
       when :local
         @local_model
       when :bedrock
@@ -266,7 +295,9 @@ module RailsConsoleAi
       return @max_tokens if @max_tokens
 
       family = self.class.model_family(resolved_model)
-      family ? family[:max_tokens] : 4096
+      return family[:max_tokens] if family
+
+      @provider == :openrouter ? 16_000 : 4096
     end
 
     # Returns nil for model families that reject the `temperature` parameter
@@ -292,6 +323,8 @@ module RailsConsoleAi
         'claude-opus-5'
       when :openai
         'gpt-5.3-codex'
+      when :openrouter
+        'anthropic/claude-opus-5'
       when :local
         @local_model
       when :bedrock
@@ -303,6 +336,12 @@ module RailsConsoleAi
       @provider == :local ? [@timeout, 300].max : @timeout
     end
 
+    ENV_KEYS = {
+      anthropic: 'ANTHROPIC_API_KEY',
+      openai: 'OPENAI_API_KEY',
+      openrouter: 'OPENROUTER_API_KEY'
+    }.freeze
+
     def validate!
       unless PROVIDERS.include?(@provider)
         raise ConfigurationError, "Unknown provider: #{@provider}. Valid: #{PROVIDERS.join(', ')}"
@@ -319,7 +358,7 @@ module RailsConsoleAi
         end
       else
         unless resolved_api_key
-          env_var = @provider == :anthropic ? 'ANTHROPIC_API_KEY' : 'OPENAI_API_KEY'
+          env_var = ENV_KEYS[@provider] || 'API_KEY'
           raise ConfigurationError, "No API key. Set config.api_key or #{env_var} env var."
         end
       end