activeagent 1.9.3 → 1.9.5

data/lib/active_agent/cli.rb

@@ -0,0 +1,300 @@
+# frozen_string_literal: true
+
+require "json"
+require "optparse"
+require_relative "version"
+
+module ActiveAgent
+  # The `activeagent` executable: a dashboard's evaluations, scenario
+  # catalogs, agents and traces from a terminal or a CI job, over HTTP with a
+  # dashboard API key. Plain Ruby (OptionParser and Net::HTTP); it loads
+  # neither Rails nor the framework, so it starts fast and runs anywhere the
+  # gem is installed.
+  #
+  #   activeagent login --url https://ops.example.com/activeagents --key aa_...
+  #   activeagent evals run "Support orders" --wait --min-pass-rate 0.8
+  #
+  # Every command answers through an API-key-authenticated endpoint: the MCP
+  # facade's dashboard tools (<mount>/mcp) with the dashboard API key, or the
+  # ingest endpoints the framework's own reporters post to (the report
+  # collector at <mount>/api/evaluation_reports, trace ingest at
+  # <mount>/api/traces) with the ingest key. A dashboard that does not offer
+  # what a command needs (an older engine, or one that turned the dashboard
+  # tools off) exits EXIT_UNAVAILABLE saying so.
+  #
+  # CLI.start returns the exit code rather than exiting, so it can be called
+  # from Ruby and tested in process.
+  class CLI
+    EXIT_SUCCESS = 0
+    # A request failed or the dashboard refused it.
+    EXIT_FAILURE = 1
+    # The command line was wrong.
+    EXIT_USAGE = 2
+    # No dashboard URL or key to use.
+    EXIT_CONFIG = 3
+    # An evaluation run failed, or passed fewer scenarios than --min-pass-rate.
+    EXIT_GATE = 4
+    # The dashboard does not offer what the command needs: an older engine,
+    # or one with its dashboard tools turned off.
+    EXIT_UNAVAILABLE = 5
+
+    # Every failure a command reports: the message is printed and the exit
+    # code returned. +status+ is the HTTP status or JSON-RPC code behind it.
+    class Error < StandardError
+      attr_reader :exit_code, :status
+
+      def initialize(message = nil, exit_code: EXIT_FAILURE, status: nil)
+        super(message)
+        @exit_code = exit_code
+        @status = status
+      end
+    end
+
+    def self.version
+      ActiveAgent::VERSION
+    end
+
+    def self.start(argv = ARGV, **options)
+      new(**options).run(argv.dup)
+    end
+
+    # +sleeper+ and +clock+ let tests drive `evals run --wait` without
+    # waiting.
+    def initialize(out: $stdout, err: $stderr, input: $stdin, env: ENV, credentials_path: nil,
+                   sleeper: ->(seconds) { sleep(seconds) }, clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })
+      @out = out
+      @err = err
+      @input = input
+      @env = env
+      @credentials = Credentials.new(credentials_path || Credentials.default_path(env))
+      @sleeper = sleeper
+      @clock = clock
+      @options = {}
+    end
+
+    def run(argv)
+      global_parser.order!(argv)
+      return print_version if @options[:version]
+
+      command = argv.shift
+      return print_help(global_parser) if command.nil? || command == "help" || @options[:help]
+
+      dispatch(command, argv)
+    rescue OptionParser::ParseError => e
+      @err.puts "activeagent: #{e.message}"
+      @err.puts "Run `activeagent help` for usage."
+      EXIT_USAGE
+    rescue Error => e
+      @err.puts "activeagent: #{e.message}"
+      e.exit_code
+    end
+
+    COMMANDS = {
+      "login" => "Store a dashboard URL and API key as a profile",
+      "logout" => "Remove a stored profile",
+      "status" => "Check the URL and keys against the dashboard",
+      "evals" => "Evaluations: list, runs, run, report, import",
+      "catalogs" => "Scenario catalogs: list, import (or preview), export",
+      "agents" => "Agents: list, versions",
+      "traces" => "Telemetry traces: list, get, export, import",
+      "version" => "Print the version"
+    }.freeze
+
+    private
+
+    def dispatch(command, argv)
+      case command
+      when "login" then login(argv)
+      when "logout" then logout(argv)
+      when "status" then status(argv)
+      when "version" then print_version
+      when "evals" then subcommand("evals", argv, %w[list runs run report import])
+      when "catalogs" then subcommand("catalogs", argv, %w[list import export])
+      when "agents" then subcommand("agents", argv, %w[list versions])
+      when "traces" then subcommand("traces", argv, %w[list get export import])
+      else
+        raise Error.new("unknown command '#{command}'. Commands: #{COMMANDS.keys.join(", ")}", exit_code: EXIT_USAGE)
+      end
+    end
+
+    def subcommand(group, argv, names)
+      name = argv.shift
+      if name.nil? || %w[help -h --help].include?(name)
+        @out.puts "Usage: activeagent #{group} <#{names.join("|")}> [options]"
+        return name.nil? ? EXIT_USAGE : EXIT_SUCCESS
+      end
+      unless names.include?(name)
+        raise Error.new("unknown command '#{group} #{name}'. Try: #{names.map { |n| "#{group} #{n}" }.join(", ")}", exit_code: EXIT_USAGE)
+      end
+
+      send(:"#{group}_#{name}", argv)
+    end
+
+    def global_parser
+      @global_parser ||= OptionParser.new do |parser|
+        parser.banner = "Usage: activeagent <command> [options]"
+        parser.separator ""
+        parser.separator "Commands:"
+        COMMANDS.each { |name, description| parser.separator format("    %-10s %s", name, description) }
+        parser.separator ""
+        parser.separator "Options:"
+        common_options(parser)
+        parser.on("-v", "--version", "Print the version") { @options[:version] = true }
+        parser.separator ""
+        parser.separator "Environment: ACTIVEAGENT_URL, ACTIVEAGENT_API_KEY, ACTIVEAGENT_INGEST_KEY and"
+        parser.separator "ACTIVEAGENT_PROFILE override the stored profile (for CI)."
+        parser.separator "Exit codes: 0 ok, 1 failed, 2 usage, 3 not configured, 4 evaluation gate failed,"
+        parser.separator "5 not available on this dashboard (an older engine, or its dashboard tools turned off)."
+      end
+    end
+
+    # Options every command takes, before or after the command name.
+    def common_options(parser)
+      parser.on("--profile NAME", "Use this stored profile (default: ACTIVEAGENT_PROFILE or 'default')") { |value| @options[:profile] = value }
+      parser.on("--url URL", "The dashboard mount, e.g. https://ops.example.com/activeagents") { |value| @options[:url] = value }
+      parser.on("--json", "Print JSON for scripts instead of tables") { @options[:json] = true }
+      parser.on("-h", "--help", "Show help") { @options[:help] = true }
+    end
+
+    # Parses +argv+ with the command's own options plus the common ones and
+    # returns the remaining positional arguments, printing the command's help
+    # and returning nil for --help.
+    def parse(argv, banner)
+      parser = OptionParser.new do |p|
+        p.banner = "Usage: activeagent #{banner}"
+        yield p if block_given?
+        common_options(p)
+      end
+      parser.parse!(argv)
+      if @options[:help]
+        @out.puts parser
+        return nil
+      end
+      argv
+    end
+
+    def print_help(parser)
+      @out.puts parser
+      EXIT_SUCCESS
+    end
+
+    def print_version
+      @out.puts(@options[:json] ? JSON.generate(version: self.class.version) : "activeagent #{self.class.version}")
+      EXIT_SUCCESS
+    end
+
+    def profile_name
+      @options[:profile] || @env["ACTIVEAGENT_PROFILE"].to_s.then { |name| name.empty? ? "default" : name }
+    end
+
+    # The profile's stored values with the environment and --url over them.
+    def profile
+      stored = @credentials[profile_name]
+      if stored.empty? && @options[:profile] && !@env["ACTIVEAGENT_URL"]
+        raise Error.new("No profile '#{profile_name}' in #{@credentials.path}; run `activeagent login --profile #{profile_name}`",
+                        exit_code: EXIT_CONFIG)
+      end
+
+      {
+        "url" => @options[:url] || env_value("ACTIVEAGENT_URL") || stored["url"],
+        "api_key" => env_value("ACTIVEAGENT_API_KEY") || stored["api_key"],
+        "ingest_key" => env_value("ACTIVEAGENT_INGEST_KEY") || stored["ingest_key"]
+      }
+    end
+
+    def env_value(name)
+      value = @env[name].to_s.strip
+      value.empty? ? nil : value
+    end
+
+    def client
+      @client ||= begin
+        values = profile
+        if values["url"].to_s.empty?
+          raise Error.new("No dashboard URL: run `activeagent login --url <mount URL>`, or set ACTIVEAGENT_URL", exit_code: EXIT_CONFIG)
+        end
+        Client.new(url: values["url"], api_key: values["api_key"], ingest_key: values["ingest_key"])
+      end
+    end
+
+    # Prints +data+ as JSON with --json, otherwise yields for the human form.
+    def emit(data)
+      if @options[:json]
+        @out.puts JSON.pretty_generate(data)
+      else
+        yield
+      end
+      EXIT_SUCCESS
+    end
+
+    # Prints +rows+ as aligned columns. +columns+ maps each header to a
+    # proc reading a row's cell.
+    def table(rows, columns, empty: "Nothing to show.")
+      return @out.puts(empty) if rows.empty?
+
+      cells = rows.map { |row| columns.values.map { |reader| cell(reader.call(row)) } }
+      widths = columns.keys.each_with_index.map { |header, i| ([ header ] + cells.map { |c| c[i] }).map(&:length).max }
+      line = ->(values) { values.each_with_index.map { |value, i| value.ljust(widths[i]) }.join("  ").rstrip }
+      @out.puts line.call(columns.keys)
+      cells.each { |c| @out.puts line.call(c) }
+    end
+
+    def cell(value)
+      value.nil? ? "-" : value.to_s.gsub(/[[:space:]\p{C}]+/, " ")
+    end
+
+    # Writes +body+ to +path+, or prints it, ending in one newline either
+    # way. With a path, the block's line is said on standard error (not with
+    # --json, whose standard output is the only thing a script reads).
+    def write_output(body, path)
+      body = "#{body}\n" unless body.end_with?("\n")
+      if path
+        File.write(path, body)
+        @err.puts yield if block_given? && !@options[:json]
+      else
+        @out.print body
+      end
+      EXIT_SUCCESS
+    end
+
+    def read_text_file(path)
+      File.read(path)
+    rescue Errno::ENOENT, Errno::EACCES, Errno::EISDIR => e
+      raise Error.new("Cannot read #{path} (#{e.class})", exit_code: EXIT_USAGE)
+    end
+
+    def read_json_file(path)
+      document = JSON.parse(read_text_file(path))
+      raise Error.new("#{path} must hold a JSON object", exit_code: EXIT_USAGE) unless document.is_a?(Hash)
+
+      document
+    rescue JSON::ParserError
+      raise Error.new("#{path} is not valid JSON", exit_code: EXIT_USAGE), cause: nil
+    end
+
+    def require_argument(argv, name, usage)
+      value = argv.shift
+      raise Error.new("missing #{name}. Usage: activeagent #{usage}", exit_code: EXIT_USAGE) if value.to_s.empty?
+      raise Error.new("unexpected arguments: #{argv.join(" ")}", exit_code: EXIT_USAGE) unless argv.empty?
+
+      value
+    end
+
+    def positive_integer(value, name)
+      Integer(value, 10).tap { |n| raise ArgumentError unless n.positive? }
+    rescue ArgumentError, TypeError
+      raise Error.new("#{name} must be a positive integer", exit_code: EXIT_USAGE)
+    end
+
+    def list_option(value)
+      value.split(",").map(&:strip).reject(&:empty?)
+    end
+  end
+end
+
+require_relative "cli/credentials"
+require_relative "cli/client"
+require_relative "cli/session_commands"
+require_relative "cli/eval_commands"
+require_relative "cli/resource_commands"
+require_relative "cli/trace_commands"

data/lib/active_agent/concerns/preview.rb

@@ -68,7 +68,7 @@ module ActiveAgent
     class << self
       # Returns all agent preview classes.
       def all
-        load_previews if descendants.empty?
+        load_previews
         descendants.sort_by { |agent| agent.name.titleize }
       end
 
@@ -111,7 +111,7 @@ module ActiveAgent
 
       def load_previews
         preview_paths.each do |preview_path|
-          Dir["#{preview_path}/**/*_preview.rb"].sort.each { |file| require file }
+          Dir["#{preview_path}/**/*_preview.rb"].sort.each { |file| require_dependency file }
         end
       end
 

data/lib/active_agent/evals/design_tokens.rb

@@ -58,6 +58,13 @@ module ActiveAgent
         "--color-info" => "#3b82f6",
         "--color-info-soft" => "#dbeafe",
         "--color-info-text" => "#1e40af",
+        # The system and developer message roles: badge tones like the four above.
+        "--color-system" => "#8b5cf6",
+        "--color-system-soft" => "#ede9fe",
+        "--color-system-text" => "#6d28d9",
+        "--color-dev" => "#14b8a6",
+        "--color-dev-soft" => "#ccfbf1",
+        "--color-dev-text" => "#0f766e",
 
         # Trace span colors (observability)
         "--span-root" => "#9ca3af",
@@ -111,7 +118,11 @@ module ActiveAgent
         "--color-error-soft" => "rgba(220,38,38,0.15)",
         "--color-error-text" => "#f87171",
         "--color-info-soft" => "rgba(59,130,246,0.15)",
-        "--color-info-text" => "#93c5fd"
+        "--color-info-text" => "#93c5fd",
+        "--color-system-soft" => "rgba(139,92,246,0.15)",
+        "--color-system-text" => "#c4b5fd",
+        "--color-dev-soft" => "rgba(20,184,166,0.15)",
+        "--color-dev-text" => "#5eead4"
       }.freeze
 
       # One CSS rule declaring `tokens` as custom properties on `scope`, with

data/lib/active_agent/evals/publisher.rb

@@ -10,9 +10,11 @@ module ActiveAgent
   module Evals
     # Publishes a completed report without replaying the agent. The caller must
     # retain run_id when retrying: compatible collectors treat that identity as
-    # immutable within the authenticated account. Delivery is blocking and does
-    # not follow redirects with the account's bearer credential. +verify!+ asks
-    # the collector whether it is up and accepts the key before a run is paid for.
+    # immutable within the authenticated account once the report is complete.
+    # Delivery is blocking and does not follow redirects with the account's
+    # bearer credential. +verify!+ asks the collector whether it is up and
+    # accepts the key before a run is paid for, and +progress+ shows a run's
+    # results so far while it is still running.
     #
     # Every failure to deliver raises Error. Invalid arguments raise
     # ArgumentError before anything is sent.
@@ -94,19 +96,35 @@ module ActiveAgent
       # report may be a Report or its saved JSON hash. Full prompts, answers and
       # tool results are included; applications should make publication opt-in.
       def call(report:, run_id:, source:, agent_name:, suite:)
-        body = encode(self.class.envelope(report: report, run_id: run_id, source: source, agent_name: agent_name, suite: suite))
-        raise Error, "Evaluation report exceeds the 2 MiB delivery limit; publish a smaller selection" if body.bytesize > MAX_BYTES
-
-        deliver("retain the report and run_id for retry") do
-          response = post(body)
-          raise rejection(response) unless %w[200 201].include?(response.code)
+        envelope = self.class.envelope(report: report, run_id: run_id, source: source, agent_name: agent_name, suite: suite)
+        publish(envelope, accepted: %w[complete], receipt: "completion receipt")
+      end
 
-          receipt = JSON.parse(response.body.to_s)
-          unless receipt.is_a?(Hash) && receipt["run_id"] == run_id && receipt["status"] == "complete" && receipt["id"] && receipt["evaluation_id"]
-            raise Error.new("Evaluation collector returned an invalid completion receipt; retain the report and run_id for retry", retryable: true)
-          end
-          receipt
+      # Returns the collector's receipt for the results +report+ holds so far,
+      # which the collector shows as a running run under +run_id+. Each call
+      # replaces the results the previous one sent; +call+ with the finished
+      # report under the same run_id completes the run. The receipt's status
+      # is "running", or "complete" when the run already finished.
+      #
+      # Raises Error, without sending the report, when the collector does not
+      # list "progress" among its capabilities (see +supports_progress?+): a
+      # collector that predates progress would store the partial report as
+      # complete.
+      def progress(report:, run_id:, source:, agent_name:, suite:)
+        unless supports_progress?
+          raise Error, "Evaluation collector does not accept progress; publish the finished report with call"
         end
+
+        envelope = self.class.envelope(report: report, run_id: run_id, source: source, agent_name: agent_name, suite: suite, status: "running")
+        publish(envelope, accepted: %w[running complete], receipt: "progress receipt")
+      end
+
+      # Returns true when the collector accepts +progress+. Asks it once, with
+      # the probe +verify!+ sends, unless +verify!+ already has; raises as
+      # +verify!+ does.
+      def supports_progress?
+        verify! if @capabilities.nil?
+        @capabilities.include?("progress")
       end
 
       # Returns true when the collector is up and accepts the API key, without
@@ -117,6 +135,8 @@ module ActiveAgent
       # a stopped collector or a refused key fails before the first model call
       # rather than after the last one.
       #
+      # The refusal's +capabilities+ is what +supports_progress?+ reads.
+      #
       # Raises Error for anything else: a rejection other than 422, with the
       # status, detail and guidance +call+ would carry (401 for a refused key,
       # 404 when nothing at the endpoint takes reports); a retryable delivery
@@ -128,7 +148,10 @@ module ActiveAgent
           response = post("{}")
           if response.code == "422"
             detail = collector_detail(response.body)
-            next true if detail&.match?(/\bversion\b/)
+            if detail&.match?(/\bversion\b/)
+              @capabilities = collector_capabilities(response.body)
+              next true
+            end
 
             raise Error.new("Evaluation collector answered HTTP 422 without refusing the empty envelope as a version-1 report, " \
                             "so it is not a compatible collector; check the endpoint", status: 422, detail: detail)
@@ -144,9 +167,12 @@ module ActiveAgent
       # collector's export of a stored run returns, so the export can be
       # posted again. report may be a Report or its saved JSON hash.
       #
+      # `status: "running"` marks the envelope +progress+ sends; a complete
+      # report's envelope carries no status.
+      #
       # Raises ArgumentError for an identity that is not a nonempty string,
       # or a report that is neither.
-      def self.envelope(report:, run_id:, source:, agent_name:, suite:)
+      def self.envelope(report:, run_id:, source:, agent_name:, suite:, status: nil)
         identities = { "run_id" => run_id, "source" => source, "agent_name" => agent_name, "suite" => suite }
         identities.each do |key, value|
           raise ArgumentError, "#{key} must be a nonempty string" unless value.is_a?(String) && !value.strip.empty?
@@ -154,11 +180,40 @@ module ActiveAgent
         hash = report.to_h if report.respond_to?(:to_h) && !report.nil? && !report.is_a?(Array)
         raise ArgumentError, "report must be a Report or its saved JSON hash" unless hash.is_a?(Hash)
 
-        identities.merge("version" => 1, "report" => hash)
+        envelope = identities.merge("version" => 1, "report" => hash)
+        status ? envelope.merge("status" => status) : envelope
       end
 
       private
 
+      # Delivers +envelope+ and returns the collector's receipt, which must name
+      # the envelope's run_id, a stored run, and one of the +accepted+ statuses.
+      def publish(envelope, accepted:, receipt:)
+        body = encode(envelope)
+        raise Error, "Evaluation report exceeds the 2 MiB delivery limit; publish a smaller selection" if body.bytesize > MAX_BYTES
+
+        deliver("retain the report and run_id for retry") do
+          response = post(body)
+          raise rejection(response) unless %w[200 201].include?(response.code)
+
+          answer = JSON.parse(response.body.to_s)
+          unless answer.is_a?(Hash) && answer["run_id"] == envelope["run_id"] && accepted.include?(answer["status"]) &&
+                 answer["id"] && answer["evaluation_id"]
+            raise Error.new("Evaluation collector returned an invalid #{receipt}; retain the report and run_id for retry", retryable: true)
+          end
+          answer
+        end
+      end
+
+      # The string entries of a JSON object body's +capabilities+ array, or none.
+      def collector_capabilities(body)
+        parsed = JSON.parse(body.to_s)
+        list = parsed["capabilities"] if parsed.is_a?(Hash)
+        list.is_a?(Array) ? list.grep(String).freeze : [].freeze
+      rescue JSON::ParserError, EncodingError
+        [].freeze
+      end
+
       # Posts +body+ to the endpoint with the bearer key and the delivery timeouts.
       def post(body)
         http = Net::HTTP.new(@uri.hostname, @uri.port)

data/lib/active_agent/inline_preview_interceptor.rb

@@ -28,6 +28,7 @@ module ActiveAgent
     end
 
     def transform! # :nodoc:
+      return context unless context.respond_to?(:html_part)
       return context if html_part.blank?
 
       html_part.body = html_part.decoded.gsub(PATTERN) do |match|

data/lib/active_agent/preview/templates/layouts/active_agent/preview.html.erb

@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>ActiveAgent Previews</title>
+  <style>
+    body { color-scheme: light dark; font: 16px/1.5 system-ui, sans-serif; max-width: 1000px; padding: 1rem; margin: auto; }
+    pre { white-space: pre-wrap; overflow-wrap: anywhere; border: 1px solid; border-radius: .25rem; padding: 1rem; }
+    a { text-underline-offset: .2em; }
+  </style>
+</head>
+<body>
+  <nav><%= link_to "All agent previews", rails_agent_previews_path %></nav>
+  <%= yield %>
+</body>
+</html>

data/lib/active_agent/preview/templates/rails/agents/index.html.erb

@@ -0,0 +1,14 @@
+<h1>Agent Previews</h1>
+<% if @previews.empty? %>
+  <p>No previews found. Generate an agent or add an ActiveAgent::Preview subclass under test/agents/previews.</p>
+<% end %>
+<% @previews.each do |preview| %>
+  <section>
+    <h2><%= preview.preview_name %></h2>
+    <ul>
+      <% preview.prompts.each do |prompt| %>
+        <li><%= link_to prompt, rails_agent_preview_path("#{preview.preview_name}/#{prompt}") %></li>
+      <% end %>
+    </ul>
+  </section>
+<% end %>

data/lib/active_agent/preview/templates/rails/agents/preview.html.erb

@@ -0,0 +1,3 @@
+<h1><%= @preview.preview_name %> / <%= @prompt %></h1>
+<p><%= link_to "Download Markdown", "#{download_rails_agent_preview_path("#{@preview.preview_name}/#{@prompt}")}?#{request.query_parameters.to_query}" %></p>
+<pre><%= @content %></pre>

data/lib/active_agent/railtie.rb

@@ -6,6 +6,8 @@ require "active_agent"
 require "active_agent/railtie/schema_generator_extension"
 require "abstract_controller/railties/routes_helpers"
 
+Rails.autoload :AgentsController, "rails/agents_controller"
+
 module ActiveAgent
   class Railtie < Rails::Railtie # :nodoc:
     config.active_agent = ActiveSupport::OrderedOptions.new
@@ -101,8 +103,12 @@ module ActiveAgent
     end
 
     initializer "active_agent.set_autoload_paths", before: :set_autoload_paths do |app|
-      # options = app.config.active_agent
-      # app.config.paths["test/agents/previews"].concat(options.preview_paths)
+      options = app.config.active_agent
+      options.preview_paths |= [ "#{app.root}/test/agents/previews", "#{app.root}/test/docs/previews" ]
+      # This runs before set_configs assigns show_previews its development default.
+      if options.show_previews.nil? ? Rails.env.development? : options.show_previews
+        app.config.autoload_paths.concat(options.preview_paths)
+      end
     end
 
     initializer "active_agent.compile_config_methods" do
@@ -132,9 +138,9 @@ module ActiveAgent
 
       if options.show_previews
         app.routes.prepend do
-          get "/rails/agents" => "rails/agents#index", :internal => true
-          get "/rails/agents/download/*path" => "rails/agents#download", :internal => true
-          get "/rails/agents/*path" => "rails/agents#preview", :internal => true
+          get "/rails/agents" => "rails/agents#index", :internal => true, :as => :rails_agent_previews
+          get "/rails/agents/download/*path" => "rails/agents#download", :internal => true, :as => :download_rails_agent_preview, :format => false
+          get "/rails/agents/*path" => "rails/agents#preview", :internal => true, :as => :rails_agent_preview, :format => false
         end
       end
     end

data/lib/active_agent/version.rb

@@ -1,3 +1,3 @@
 module ActiveAgent
-  VERSION = "1.9.3"
+  VERSION = "1.9.5"
 end

data/lib/generators/test_unit/agent_generator.rb

@@ -17,7 +17,7 @@ module TestUnit # :nodoc:
       end
 
       def create_preview_files
-        template "preview.rb", File.join("test/docs/previews", class_path, "#{file_name}_agent_preview.rb")
+        template "preview.rb", File.join("test/agents/previews", class_path, "#{file_name}_agent_preview.rb")
       end
 
       private

data/lib/generators/test_unit/templates/functional_test.rb.tt

@@ -1,7 +1,7 @@
 require "test_helper"
 
 <% module_namespacing do -%>
-class <%= class_name %>AgentTest < ActiveAgent::TestCase
+class <%= class_name %>AgentTest < ActiveSupport::TestCase
 <% actions.each_with_index do |action, index| -%>
 <% if index != 0 -%>
 

data/lib/generators/test_unit/templates/preview.rb.tt

@@ -1,13 +1,13 @@
 <% module_namespacing do -%>
-# Preview all agent views/prompts templates at http://localhost:3000/active_agent/agents/<%= file_path %>_agent
+# Preview all agent views/prompts templates at http://localhost:3000/rails/agents/<%= file_path %>_agent
 class <%= class_name %>AgentPreview < ActiveAgent::Preview
 <% actions.each_with_index do |action, index| -%>
 <% if index != 0 -%>
 
 <% end -%>
-  # Preview this email at http://localhost:3000/active_agent/agents/<%= file_path %>_agent/<%= action %>
+  # Preview this prompt at http://localhost:3000/rails/agents/<%= file_path %>_agent/<%= action %>
   def <%= action %>
-    <%= class_name %>Agent.<%= action %>
+    <%= class_name %>Agent.with(params).<%= action %>
   end
 <% end -%>
 end

data/lib/rails/agents_controller.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "rails/application_controller"
+
+class Rails::AgentsController < Rails::ApplicationController # :nodoc:
+  prepend_view_path File.expand_path("../active_agent/preview/templates", __dir__)
+  layout "active_agent/preview"
+  before_action :require_local!
+
+  def index
+    @previews = ActiveAgent::Preview.all
+  end
+
+  def preview
+    if found = ActiveAgent::Preview.find(params[:path])
+      @previews = [ found ]
+      render :index
+    elsif load_preview
+      render :preview
+    end
+  end
+
+  def download
+    return unless load_preview
+
+    send_data @content, type: "text/markdown", disposition: "attachment",
+      filename: "#{@preview.preview_name.tr('/', '-')}-#{@prompt}.md"
+  end
+
+  private
+
+  def load_preview
+    name, _, @prompt = params[:path].to_s.rpartition("/")
+    @preview = ActiveAgent::Preview.find(name)
+    unless @preview&.prompt_exists?(@prompt)
+      head :not_found
+      return false
+    end
+
+    @content = @preview.call(@prompt, request.query_parameters).prompt_preview
+    true
+  end
+end