rails_console_ai 0.35.0 → 0.38.0

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
@@ -8,19 +8,23 @@ module RailsConsoleAi
     # (us.anthropic.claude-sonnet-5, global.anthropic.claude-opus-4-6-v1).
     #
     # input/output are $ per MTok (converted to per-token in .pricing_for).
-    # Cache pricing is derived: read = 0.1x input, write = 1.25x input.
+    # Cache pricing is derived: read = 0.1x input, write = 1.25x input, unless a
+    # family sets cache_read ($ per MTok) explicitly (opus-5-5 reads at 0.05x).
     # temperature: false marks families that reject the `temperature` parameter
-    # (removed on opus-4-7+, sonnet-5, and fable-5).
+    # (removed on opus-4-7+, sonnet-5+, and fable-5).
+    # effort: false marks families that reject `output_config.effort` (haiku-4-5).
     # max_tokens is the OUTPUT cap we request; context is the total window.
     MODEL_FAMILIES = {
       'claude-fable-5'    => { input: 10.0, output: 50.0, max_tokens: 16_000, context: 1_000_000, temperature: false },
+      'claude-opus-5-5'   => { input: 4.0,  output: 20.0, cache_read: 0.20, max_tokens: 16_000, context: 1_000_000, temperature: false },
       'claude-opus-5'     => { input: 5.0,  output: 25.0, max_tokens: 16_000, context: 1_000_000, temperature: false },
       'claude-opus-4-8'   => { input: 5.0,  output: 25.0, max_tokens: 16_000, context: 1_000_000, temperature: false },
       'claude-opus-4-7'   => { input: 5.0,  output: 25.0, max_tokens: 16_000, context: 1_000_000, temperature: false },
       'claude-opus-4-6'   => { input: 5.0,  output: 25.0, max_tokens: 16_000, context: 1_000_000, temperature: true },
+      'claude-sonnet-5-5' => { input: 2.0,  output: 10.0, max_tokens: 16_000, context: 1_000_000, temperature: false },
       'claude-sonnet-5'   => { input: 2.0,  output: 10.0, max_tokens: 16_000, context: 1_000_000, temperature: false },
       'claude-sonnet-4-6' => { input: 3.0,  output: 15.0, max_tokens: 16_000, context: 1_000_000, temperature: true },
-      'claude-haiku-4-5'  => { input: 1.0,  output: 5.0,  max_tokens: 16_000, context: 200_000,   temperature: true },
+      'claude-haiku-4-5'  => { input: 1.0,  output: 5.0,  max_tokens: 16_000, context: 200_000,   temperature: true, effort: false },
     }.freeze
 
     # Assumed context window for models with no family entry — local models and
@@ -28,18 +32,28 @@ module RailsConsoleAi
     # little early, over-guessing means no warning before the request is rejected.
     DEFAULT_CONTEXT_WINDOW = 200_000
 
+    EFFORT_LEVELS = %w[low medium high xhigh max].freeze
+
     # Family keys sorted longest-first so a more specific family always wins
-    # if keys ever overlap (e.g. a future 'claude-sonnet-5-5' entry would match
-    # before 'claude-sonnet-5').
+    # when keys overlap (e.g. 'claude-sonnet-5-5' matches before 'claude-sonnet-5').
     MODEL_FAMILY_KEYS = MODEL_FAMILIES.keys.sort_by { |k| -k.length }.freeze
 
     # Returns the family attributes for a model ID, or nil for unknown models.
     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
 
+    # The effort a model would be sent, or nil when it takes none: unknown models
+    # (OpenAI, local) and families marked effort: false.
+    def self.effort_for(model_id, effort)
+      return nil if effort.nil? || effort.to_s.empty?
+      family = model_family(model_id)
+      family && family[:effort] != false ? effort.to_s : nil
+    end
+
     # Per-token pricing for a model ID, matched by family. Returns
     # { input:, output:, cache_read:, cache_write: } or nil for unknown models.
     # Cache reads bill at 0.1x the base input rate; cache writes at 1.25x for the
@@ -51,11 +65,27 @@ module RailsConsoleAi
       {
         input: input,
         output: family[:output] / 1_000_000,
-        cache_read: input * 0.1,
+        cache_read: family[:cache_read] ? family[:cache_read] / 1_000_000 : input * 0.1,
         cache_write: input * (cache_ttl.to_s == '1h' ? 2.0 : 1.25),
       }
     end
 
+    # 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)
@@ -81,7 +111,8 @@ module RailsConsoleAi
       }
     ].freeze
 
-    attr_accessor :provider, :api_key, :model, :thinking_model, :max_tokens,
+    attr_accessor :provider, :api_key, :model, :thinking_model, :cheap_model, :max_tokens,
+                  :effort, :thinking_effort,
                   :auto_execute, :temperature,
                   :timeout, :open_timeout, :max_retries, :debug, :max_tool_rounds,
                   :error_hints,
@@ -93,19 +124,29 @@ 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,
+                  :base_url,
+                  :artifact_date_prefix
 
     def initialize
       @provider     = :anthropic
       @api_key      = nil
       @model        = nil
       @thinking_model = nil
+      @cheap_model  = nil
+      # The default and thinking tiers run the same model by default and differ
+      # only in how hard it thinks. Sent as output_config.effort, and only to
+      # model families that accept it. The cheap tier sends no effort.
+      @effort          = 'medium'
+      @thinking_effort = 'high'
       @max_tokens   = nil
       @auto_execute = false
       @temperature  = 0.2
@@ -147,6 +188,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 +198,18 @@ 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
+      # Public base URL of the host app, e.g. "https://secure.apptoto.com". Used
+      # to build links the gem hands out — an artifact URL is read in a console,
+      # pasted into Slack or opened on a phone, where a bare path is useless.
+      # Falls back to the app's default_url_options, then to a relative path.
+      @base_url = nil
+      # Stamp new artifact names with the day they were made ("20260911_Churn
+      # report"), so a list of them reads chronologically. Updates keep the name
+      # and date they were created with.
+      @artifact_date_prefix = true
     end
 
     def resolve_user_extra_info(username)
@@ -240,6 +296,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
@@ -250,11 +308,32 @@ module RailsConsoleAi
     def resolved_model
       return @model if @model && !@model.empty?
 
+      case @provider
+      when :anthropic
+        'claude-opus-5-5'
+      when :openai
+        'gpt-5.3-codex'
+      when :openrouter
+        'anthropic/claude-opus-5.5'
+      when :local
+        @local_model
+      when :bedrock
+        'us.anthropic.claude-opus-5-5'
+      end
+    end
+
+    # The model /cheap switches to: faster and cheaper than the default, for
+    # routine lookups where the default's depth isn't needed.
+    def resolved_cheap_model
+      return @cheap_model if @cheap_model && !@cheap_model.empty?
+
       case @provider
       when :anthropic
         'claude-sonnet-5'
       when :openai
         'gpt-5.3-codex'
+      when :openrouter
+        'anthropic/claude-sonnet-5'
       when :local
         @local_model
       when :bedrock
@@ -266,17 +345,24 @@ 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
-    # (opus-4-7+, sonnet-5, fable-5) so providers omit the field from the request.
+    # (opus-4-7+, sonnet-5+, fable-5) so providers omit the field from the request.
     def resolved_temperature
       family = self.class.model_family(resolved_model)
       return nil if family && family[:temperature] == false
       @temperature
     end
 
+    # Returns the effort to send for the configured model, or nil to omit it.
+    def resolved_effort
+      self.class.effort_for(resolved_model, @effort)
+    end
+
     # Returns '1h' when the 1-hour prompt cache is requested, else nil (the
     # 5-minute default). Providers that offer only one cache duration ignore it.
     def resolved_cache_ttl
@@ -289,13 +375,15 @@ module RailsConsoleAi
 
       case @provider
       when :anthropic
-        'claude-opus-5'
+        'claude-opus-5-5'
       when :openai
         'gpt-5.3-codex'
+      when :openrouter
+        'anthropic/claude-opus-5.5'
       when :local
         @local_model
       when :bedrock
-        'us.anthropic.claude-opus-5'
+        'us.anthropic.claude-opus-5-5'
       end
     end
 
@@ -303,11 +391,22 @@ 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(', ')}"
       end
 
+      { effort: @effort, thinking_effort: @thinking_effort }.each do |name, value|
+        next if value.nil? || EFFORT_LEVELS.include?(value.to_s)
+        raise ConfigurationError, "Invalid #{name}: #{value.inspect}. Valid: #{EFFORT_LEVELS.join(', ')}"
+      end
+
       if @provider == :local
         raise ConfigurationError, "No local_url configured for :local provider." unless @local_url && !@local_url.empty?
       elsif @provider == :bedrock
@@ -319,7 +418,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

data/lib/rails_console_ai/context_builder.rb

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