rails_console_ai 0.36.0 → 0.38.0

data/lib/rails_console_ai/providers/openrouter.rb

@@ -32,6 +32,10 @@ module RailsConsoleAi
         # 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 }
+        # OpenRouter maps `verbosity` to Anthropic's output_config.effort; its
+        # `reasoning.effort` sets a thinking-token budget instead.
+        effort = config.resolved_effort
+        body[:verbosity] = effort if effort
         body
       end
 
@@ -76,7 +80,11 @@ module RailsConsoleAi
           result.input_tokens = [result.input_tokens - cache_read - cache_write, 0].max
         end
 
-        if result.tool_calls&.any?
+        # Some OpenRouter upstreams return tool calls with a finish_reason of
+        # "stop"; trust the calls over the label. Not when the response was cut
+        # off at the output cap, though — those arguments are half-written, and
+        # promoting them to :tool_use hands the engine a truncated call to run.
+        if result.tool_calls&.any? && !result.truncated?
           result.stop_reason = :tool_use
         end
 

data/lib/rails_console_ai/slack_bot.rb

@@ -453,7 +453,7 @@ module RailsConsoleAi
         Thread.current.report_on_exception = false
         Thread.current[:log_prefix] = "[#{channel_id}/#{thread_ts}]#{channel_log_tag(channel_id)} @#{user_name}"
         begin
-          channel.display_status("_session: #{channel_id}/#{thread_ts}_")
+          channel.display_status("_#{session_reference(engine, text, channel_id, thread_ts)}_")
           if restored
             puts "Restored session for thread #{thread_ts} (#{engine.history.length} messages)"
             channel.display_status("_(session restored — continuing from previous conversation)_")
@@ -468,6 +468,32 @@ module RailsConsoleAi
       end
     end
 
+    # A link to the session's page, so whoever is in the thread can find the
+    # transcript later. Falls back to the channel/thread pair the logs are
+    # tagged with when there is no row to link to, or no host to link with.
+    def session_reference(engine, text, channel_id, thread_ts)
+      session_id = engine.ensure_session_record(text)
+      unless session_id
+        return session_reference_fallback(channel_id, thread_ts, "no session row (session_logging off, or the sessions table not found)")
+      end
+
+      url = RailsConsoleAi.session_url(session_id)
+      unless url.start_with?('http')
+        return session_reference_fallback(channel_id, thread_ts, "no host for #{url} (set config.base_url)")
+      end
+
+      "Session ##{session_id}: <#{url}|view transcript>"
+    rescue => e
+      session_reference_fallback(channel_id, thread_ts, "#{e.class}: #{e.message}")
+    end
+
+    # Said on stdout, where the bot's own log goes, so a missing link is explained.
+    # The session thread already prefixes the line with the channel and thread.
+    def session_reference_fallback(channel_id, thread_ts, reason)
+      puts "no session link: #{reason}"
+      "Session: #{channel_id}/#{thread_ts}"
+    end
+
     def restore_from_db(engine, thread_ts)
       require 'rails_console_ai/session_logger'
       saved = SessionLogger.find_by_slack_thread(thread_ts)
@@ -652,14 +678,11 @@ module RailsConsoleAi
       when 'model'
         summary = bang_model(engine)
         post_message(channel: channel_id, thread_ts: thread_ts, text: summary)
-      when 'think'
-        model = engine.upgrade_to_thinking_model
+      when 'think', 'unthink', 'cheap'
+        tier = { 'think' => :thinking, 'unthink' => :default, 'cheap' => :cheap }[cmd]
+        engine.switch_model_tier(tier)
         post_message(channel: channel_id, thread_ts: thread_ts,
-          text: "Switched to thinking model: `#{model}`")
-      when 'unthink'
-        model = engine.downgrade_from_thinking_model
-        post_message(channel: channel_id, thread_ts: thread_ts,
-          text: "Switched to default model: `#{model}`")
+          text: "Switched to #{tier} model: `#{engine.effective_model_label}`")
       when 'context'
         summary = bang_context(engine)
         post_message(channel: channel_id, thread_ts: thread_ts, text: summary)
@@ -678,7 +701,7 @@ module RailsConsoleAi
           end
         end
       else
-        commands = %w[name usage cost model compact think unthink context retry].map { |c| "`!#{c}`" }
+        commands = %w[name usage cost model compact think unthink cheap context retry].map { |c| "`!#{c}`" }
         post_message(channel: channel_id, thread_ts: thread_ts,
           text: "Unknown command `!#{cmd}`. Available: #{commands.join(', ')}")
       end
@@ -705,13 +728,18 @@ module RailsConsoleAi
     def bang_model(engine = nil)
       config = RailsConsoleAi.configuration
       model = engine ? engine.effective_model : config.resolved_model
-      thinking = config.resolved_thinking_model
       pricing = Configuration.pricing_for(model)
+      with_effort = lambda do |m, e|
+        e = Configuration.effort_for(m, e)
+        e ? "`#{m}` (#{e} effort)" : "`#{m}`"
+      end
 
       lines = ["*Model info:*"]
       lines << "  Provider: `#{config.provider}`"
-      lines << "  Model: `#{model}`"
-      lines << "  Thinking model: `#{thinking}`"
+      lines << (engine ? "  Model: `#{engine.effective_model_label}` [#{engine.model_tier}]" : "  Model: `#{model}`")
+      lines << "  Default model: #{with_effort.(config.resolved_model, config.effort)}"
+      lines << "  Thinking model: #{with_effort.(config.resolved_thinking_model, config.thinking_effort)}"
+      lines << "  Cheap model: `#{config.resolved_cheap_model}`"
       lines << "  Max tokens: #{config.resolved_max_tokens}"
       if pricing
         lines << "  Pricing: $#{pricing[:input] * 1_000_000}/M in, $#{pricing[:output] * 1_000_000}/M out"

data/lib/rails_console_ai/slash_commands.rb

@@ -28,6 +28,7 @@ module RailsConsoleAi
       'model'   => 'Show provider, model, and pricing info',
       'think'   => 'Switch to thinking model',
       'unthink' => 'Switch back to default model',
+      'cheap'   => 'Switch to the cheaper, faster model',
       'compact' => 'Summarize conversation to reduce context',
       'usage'   => 'Show session token totals',
       'cost'    => 'Show cost estimate by model',

data/lib/rails_console_ai/sub_agent.rb

@@ -87,6 +87,15 @@ module RailsConsoleAi
         @cost += result.cost || 0
 
         break if channel.cancelled?
+
+        # Cut off at the output cap: the tool call it was writing is incomplete
+        # and gets discarded, so the sub-agent would otherwise return whatever
+        # half-sentence preceded it as if that were its finding.
+        if result.truncated?
+          channel.display_warning("  Sub-agent response hit the output-token cap — its result is incomplete.")
+          break
+        end
+
         break unless result.tool_use?
 
         # Display the LLM's reasoning text before executing its tool calls
@@ -202,6 +211,7 @@ module RailsConsoleAi
       parts << base_instructions unless @agent_config['skip_base_instructions']
       parts << guide_context
       parts << pinned_memory_context
+      parts << memory_context if memory_recall_available?
       parts << @agent_config['body'] if @agent_config['body'] && !@agent_config['body'].strip.empty?
       parts.compact.join("\n\n")
     end
@@ -217,6 +227,9 @@ module RailsConsoleAi
         - Use tools to look up schema/model details rather than guessing.
         - Prefer ActiveRecord query interface over raw SQL.
         - Use describe_model to understand models before querying them.
+        - Check the Memories section below BEFORE investigating. If a memory looks relevant,
+          call recall_memory (by name) or recall_memories (by keyword) to read it, and apply it.
+          Memories record how this app actually works; do not rediscover what one already says.
         - NEVER fabricate URLs, IDs, or data. Always look things up using model methods.
         - When you find methods on a model (e.g. via .methods.grep), USE them rather than
           constructing values manually.
@@ -235,6 +248,21 @@ module RailsConsoleAi
       nil
     end
 
+    # Same memory index the main agent sees, so the sub-agent knows what it can
+    # recall instead of finding out only if it happens to call recall_memories.
+    def memory_context
+      require 'rails_console_ai/context_builder'
+      ContextBuilder.new(RailsConsoleAi.configuration).memory_context
+    end
+
+    # An agent definition can restrict tools; the output-explorer does, to
+    # execute_code alone. Listing memories it cannot recall would only invite
+    # calls to a tool it does not have.
+    def memory_recall_available?
+      allowed = @agent_config['tools']
+      allowed.nil? || Array(allowed).include?('recall_memories')
+    end
+
     def pinned_memory_context
       channel_mode = @parent_channel.respond_to?(:mode) ? @parent_channel.mode : nil
       # For sub-agents spawned from Slack, use the Slack channel's pinned memories.

data/lib/rails_console_ai/tools/registry.rb

@@ -6,7 +6,7 @@ module RailsConsoleAi
       attr_reader :definitions, :last_sub_agent_usage
 
       # Tools that should never be cached (side effects or user interaction)
-      NO_CACHE = %w[ask_user save_memory delete_memory recall_memory execute_code execute_plan activate_skill save_skill delete_skill save_agent delete_agent delegate_task explore_output].freeze
+      NO_CACHE = %w[ask_user save_memory delete_memory recall_memory execute_code execute_plan activate_skill save_skill delete_skill save_agent delete_agent delegate_task explore_output save_artifact list_artifacts read_artifact delete_artifact].freeze
 
       def initialize(executor: nil, mode: :default, channel: nil, allowed_tools: nil)
         @executor = executor
@@ -258,6 +258,236 @@ module RailsConsoleAi
             register_execute_plan
             register_delegate_task
           end
+
+          register_artifact_tools
+        end
+      end
+
+      ARTIFACT_TYPES = %w[text/html text/markdown text/csv application/json text/plain].freeze
+
+      # How much of an artifact read_artifact returns inline before handing back
+      # an output_id instead. A full report would otherwise swamp the context.
+      ARTIFACT_READ_LIMIT = 12_000
+
+      def register_artifact_tools
+        register(
+          name: 'save_artifact',
+          description: 'Save a generated file — an HTML report, a CSV extract, a JSON dump — so the user can open it in a browser ' \
+            'instead of reading it in the console. Use this whenever the user asks for a summary, report, export or page, ' \
+            'or whenever the output is a document rather than an answer. ' \
+            'Returns a URL to view it. Prefer this over printing hundreds of lines of HTML or CSV into the transcript. ' \
+            'New artifacts are stamped with today\'s date automatically — pass a plain title like "Q3 churn summary", ' \
+            'not a dated one. Saving under a name that already exists REPLACES its content and bumps its revision; ' \
+            'to revise an artifact from an earlier day pass its exact handle (e.g. "20260911_Q3 churn summary") as the name, ' \
+            'and call read_artifact first if you need to keep most of what is already there. ' \
+            'HTML is rendered in a sandboxed frame: inline CSS works, but scripts never run, so do not rely on JavaScript ' \
+            'or on loading anything over the network — inline all styles and embed any data directly. ' \
+            'IMPORTANT: content must be the complete literal text, never a placeholder to fill in later. ' \
+            'If the content already exists as a value in the console — a file you read, a string you built — do NOT ' \
+            'retype it here. Your response has an output-token limit and a large file will be cut off mid-argument, ' \
+            'discarding the call. Use execute_code instead and save it directly from Ruby: ' \
+            'RailsConsoleAi.save_artifact(name: "Q3 churn summary", content: the_string). Same naming and revision ' \
+            'rules, and it returns the URL.',
+          parameters: {
+            'type' => 'object',
+            'properties' => {
+              'name' => { 'type' => 'string', 'description' => 'Short title, e.g. "Q3 churn summary". Reusing an existing name updates that artifact.' },
+              'content_type' => {
+                'type' => 'string',
+                'enum' => ARTIFACT_TYPES,
+                'description' => 'MIME type of the content'
+              },
+              'content' => { 'type' => 'string', 'description' => 'The full, literal file content — not a placeholder. Replaces the previous content entirely. For content that already exists as a console value, use RailsConsoleAi.save_artifact from execute_code instead.' },
+              'description' => { 'type' => 'string', 'description' => 'Optional one-line note about what this is and how it was built' }
+            },
+            'required' => ['name', 'content_type', 'content']
+          },
+          handler: ->(args) {
+            save_artifact(args['name'], args['content_type'], args['content'], args['description'])
+          }
+        )
+
+        register(
+          name: 'list_artifacts',
+          description: 'List saved artifacts, newest first, with the handle each one is addressed by. ' \
+            'Call this when the user refers to an artifact from an earlier session ("update the churn report") ' \
+            'and you do not already know its handle.',
+          parameters: {
+            'type' => 'object',
+            'properties' => {
+              'search' => { 'type' => 'string', 'description' => 'Optional filter over name and description' }
+            },
+            'required' => []
+          },
+          handler: ->(args) { list_artifacts(args['search']) }
+        )
+
+        register(
+          name: 'read_artifact',
+          description: 'Read back the content of a saved artifact so you can revise it. ' \
+            'Accepts the handle, the name, or the token from its URL.',
+          parameters: {
+            'type' => 'object',
+            'properties' => {
+              'handle' => { 'type' => 'string', 'description' => 'Handle, name, or token, e.g. "q3-churn-summary"' }
+            },
+            'required' => ['handle']
+          },
+          handler: ->(args) { read_artifact(args['handle']) }
+        )
+
+        register(
+          name: 'delete_artifact',
+          description: 'Delete a saved artifact. Only when the user asks for it to be removed.',
+          parameters: {
+            'type' => 'object',
+            'properties' => {
+              'handle' => { 'type' => 'string', 'description' => 'Handle, name, or token' }
+            },
+            'required' => ['handle']
+          },
+          handler: ->(args) { delete_artifact(args['handle']) }
+        )
+      end
+
+      # Referencing the constant is what makes Rails autoload it. `defined?` does
+      # not: under autoloading the constant is absent until something asks for it
+      # by name, so a `defined?` guard reports "no model" in a perfectly healthy
+      # app and the tool never runs. NameError is the real "no engine here" case.
+      def artifact_model
+        RailsConsoleAi::Artifact
+      rescue NameError
+        nil
+      end
+
+      # Nil when artifacts can't be used at all; otherwise the model class.
+      # Returns the explanation as a String so each tool can hand it straight back.
+      def artifact_store
+        model = artifact_model
+        return [nil, 'artifacts need the Rails engine loaded.'] unless model
+        unless model.available?
+          return [nil, 'the rails_console_ai_artifacts table does not exist. ' \
+                       'Ask the user to run `ai_db_setup` in the Rails console, then try again.']
+        end
+        [model, nil]
+      end
+
+      # Addressed by slug so the link itself says what it points at. Absolute
+      # when the app's base URL is known: this string is read in a terminal,
+      # pasted into Slack and opened on a phone, none of which resolve a path.
+      def artifact_url(artifact)
+        "#{RailsConsoleAi.base_url}#{RailsConsoleAi.engine_mount_path}/artifacts/#{artifact.slug}"
+      end
+
+      # The write itself lives on the model, shared with RailsConsoleAi.save_artifact
+      # so a console-side save and a tool-side save land identically.
+      def save_artifact(name, content_type, content, description = nil)
+        model, problem = artifact_store
+        return "FAILED to save artifact: #{problem}" if problem
+
+        existing = model.find_by(slug: model.slug_for(model.stamped_name(name)))
+        verb = existing ? 'updated' : 'saved'
+
+        artifact = model.store(name: name, content_type: content_type,
+                               content: content, description: description)
+
+        if artifact.errors.any? || artifact.new_record?
+          return "FAILED to save artifact: #{artifact.errors.full_messages.join('; ')}"
+        end
+
+        url = artifact_url(artifact)
+        revision_note = existing ? " revision #{artifact.revision}," : ''
+        if @channel
+          @channel.display_status("  Artifact #{verb}: #{artifact.name} (#{artifact.human_size}) #{url}")
+        end
+        "Artifact #{verb}: \"#{artifact.name}\" (handle: #{artifact.slug},#{revision_note} " \
+          "#{artifact.content_type}, #{artifact.human_size}). " \
+          "The user can view it at #{url} — give them that URL. " \
+          "Refer to it later as #{artifact.slug}."
+      rescue ::ActiveRecord::ActiveRecordError => e
+        "FAILED to save artifact (#{e.class}: #{e.message})."
+      end
+
+      def list_artifacts(search = nil)
+        model, problem = artifact_store
+        return "FAILED to list artifacts: #{problem}" if problem
+
+        scope = model.newest_first
+        search = search.to_s.strip
+        unless search.empty?
+          needle = "%#{search.downcase}%"
+          scope = scope.where("LOWER(name) LIKE :q OR LOWER(COALESCE(description, '')) LIKE :q", q: needle)
+        end
+
+        rows = scope.limit(50).to_a
+        if rows.empty?
+          return search.empty? ? 'No artifacts saved yet.' : "No artifacts match #{search.inspect}."
+        end
+
+        lines = rows.map { |a|
+          bits = ["#{a.slug} — \"#{a.name}\"", a.content_type, a.human_size]
+          bits << "rev #{a.revision}" if a.revision.to_i > 1
+          bits << a.updated_at.strftime('%Y-%m-%d')
+          line = bits.join(', ')
+          line += "\n    #{a.description}" if a.description.present?
+          "- #{line}"
+        }
+        "#{rows.length} artifact#{rows.length == 1 ? '' : 's'} (address one by its handle):\n#{lines.join("\n")}"
+      rescue ::ActiveRecord::ActiveRecordError => e
+        "FAILED to list artifacts (#{e.class}: #{e.message})."
+      end
+
+      def read_artifact(handle)
+        model, problem = artifact_store
+        return "FAILED to read artifact: #{problem}" if problem
+
+        artifact = model.find_by_handle(handle)
+        return artifact_not_found(model, handle) unless artifact
+
+        header = "Artifact \"#{artifact.name}\" (handle: #{artifact.slug}, #{artifact.content_type}, " \
+                 "#{artifact.human_size}, revision #{artifact.revision}):\n"
+
+        body = artifact.content.to_s
+        return header + body if body.length <= ARTIFACT_READ_LIMIT
+
+        # Same escape hatch large tool results use: keep the head, park the rest
+        # where explore_output can query it rather than flooding the context.
+        output_id = @executor && @executor.store_output(body)
+        preview = body[0, ARTIFACT_READ_LIMIT]
+        tail = if output_id
+                 "\n\n[Truncated at #{ARTIFACT_READ_LIMIT} of #{body.length} chars — " \
+                 "use explore_output with output_id=#{output_id} to query the rest, " \
+                 "or recall_output to expand it in place]"
+               else
+                 "\n\n[Truncated at #{ARTIFACT_READ_LIMIT} of #{body.length} chars]"
+               end
+        header + preview + tail
+      rescue ::ActiveRecord::ActiveRecordError => e
+        "FAILED to read artifact (#{e.class}: #{e.message})."
+      end
+
+      def delete_artifact(handle)
+        model, problem = artifact_store
+        return "FAILED to delete artifact: #{problem}" if problem
+
+        artifact = model.find_by_handle(handle)
+        return artifact_not_found(model, handle) unless artifact
+
+        name = artifact.name
+        slug = artifact.slug
+        artifact.destroy
+        @channel.display_status("  Deleted artifact: #{name}") if @channel
+        "Artifact deleted: \"#{name}\" (#{slug})."
+      rescue ::ActiveRecord::ActiveRecordError => e
+        "FAILED to delete artifact (#{e.class}: #{e.message})."
+      end
+
+      def artifact_not_found(model, handle)
+        available = model.newest_first.limit(20).pluck(:slug)
+        if available.empty?
+          "No artifact found for #{handle.inspect}. There are no saved artifacts."
+        else
+          "No artifact found for #{handle.inspect}. Available handles: #{available.join(', ')}"
         end
       end
 

data/lib/rails_console_ai/version.rb

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