actionagent 1.2.2 → 1.5.0

data/app/controllers/action_agent/api/evaluations_controller.rb

@@ -4,8 +4,24 @@ module ActionAgent
   module Api
     # CRUD + execution for agent evaluations, backing the dashboard
     # Evaluations view. Scoped to the current user's agents.
+    #
+    # An evaluation created with scenarios (a pasted list of user messages)
+    # is a scenario suite: runs replay the scenarios through the agent rather
+    # than sampling recorded generations, and can be narrowed to a group, to
+    # specific scenarios, or to specific models.
     class EvaluationsController < BaseController
+      rescue_from ActiveAgent::Evals::ScenarioParser::ParseError do |error|
+        render json: { errors: [ error.message ] }, status: :unprocessable_entity
+      end
+
       before_action :require_owner!
+      # A scenario suite replays its prompts through the provider, so creating
+      # one that runs, or running one, executes the agent and is gated the way
+      # AgentsController#execute is: the dashboard's execution switch, no
+      # observed (read-only) agents, and the owner's execution quota. Each
+      # replay then counts as one execution (ScenarioEvaluationRunner#replay).
+      before_action :require_execution_enabled!, :require_executable_scenario_agent!, :enforce_execution_quota!,
+                    only: [ :create, :run ], if: :replays_scenarios?
 
       # Default criteria used when none are supplied — all rule-based, so a
       # new evaluation produces real scores without provider credentials.
@@ -25,7 +41,7 @@ module ActionAgent
       def index
         scope = evaluations_scope
         scope = scope.where(agent_id: params[:agent_id]) if params[:agent_id].present?
-        evaluations = scope.includes(:agent, :evaluation_runs).recent.limit(50)
+        evaluations = scope.includes(:agent, :evaluation_runs, :scenarios).recent.limit(50)
 
         render json: { evaluations: evaluations.map { |evaluation| serialize(evaluation) } }
       end
@@ -36,6 +52,7 @@ module ActionAgent
 
         render json: {
           evaluation: serialize(evaluation).merge(
+            scenarios: evaluation.scenarios.ordered.map(&:as_json_summary),
             runs: evaluation.evaluation_runs.recent.limit(20).map { |run| serialize_run(run) }
           )
         }
@@ -43,11 +60,12 @@ module ActionAgent
 
       # POST /api/evaluations
       def create
-        agent = owner_agents.find(params.require(:evaluation)[:agent_id])
+        agent = requested_agent
 
         judge_kind = evaluation_params[:judge_kind].presence || "rules"
         config = {}
         config["compare_models"] = compare_models_param if compare_models_param.any?
+        scenarios = scenario_attributes
 
         evaluation = agent.evaluations.new(
           name: evaluation_params[:name],
@@ -59,9 +77,15 @@ module ActionAgent
           criteria: judge_kind == "judge_defined" ? explicit_criteria : normalized_criteria,
           config: config
         )
+        scenarios.each_with_index do |attrs, index|
+          evaluation.scenarios.build(
+            key: attrs["key"], prompt: attrs["prompt"], group: attrs["group"], notes: attrs["notes"],
+            expectations: attrs["expectations"] || {}, position: attrs.fetch("position", index)
+          )
+        end
 
         if evaluation.save
-          evaluation.run!
+          start_run(evaluation, selection_params) if run_requested?
           render json: { evaluation: serialize(evaluation.reload) }, status: :created
         else
           render json: { errors: evaluation.errors.full_messages }, status: :unprocessable_entity
@@ -69,13 +93,94 @@ module ActionAgent
       end
 
       # POST /api/evaluations/:id/run
+      # A scenario suite accepts a selection: scenario_ids[], keys[], group,
+      # models[] (or a comma-separated `models` string).
       def run
-        evaluation = evaluations_scope.find(params[:id])
-        run = evaluation.run!
+        evaluation = current_evaluation
+        run = start_run(evaluation, selection_params)
 
         render json: { evaluation: serialize(evaluation.reload), run: serialize_run(run) }
       end
 
+      # GET /api/evaluations/:id/runs/:run_id
+      # One run in full: its per-scenario, per-model results alongside the
+      # scenarios, so the matrix and every answer can be rendered, and its
+      # fix items — the faults grouped with the tools, MCP server and
+      # dashboard action that address each. Fix item paths are relative to
+      # the mount: the React app resolves them itself (dashboardPath).
+      def show_run
+        evaluation = evaluations_scope.find(params[:id])
+        run = evaluation.evaluation_runs.find(params[:run_id])
+        results = run.scenario_results.includes(:scenario).joins(:scenario)
+          .order(EvaluationScenario.arel_table[:position], EvaluationScenario.arel_table[:id], :model)
+
+        render json: {
+          evaluation: serialize(evaluation),
+          run: serialize_run(run).merge(results: results.map(&:as_json_summary), fix_items: safe_fix_items(run))
+        }
+      end
+
+      # GET /api/evaluations/:id/scenarios
+      def scenarios
+        evaluation = evaluations_scope.find(params[:id])
+
+        render json: {
+          scenarios: evaluation.scenarios.ordered.map(&:as_json_summary),
+          groups: evaluation.scenario_groups
+        }
+      end
+
+      # PUT /api/evaluations/:id/scenarios
+      # Replaces the suite from pasted text (`scenarios_text`) or a list
+      # (`scenarios`). Scenarios whose key survives keep their results.
+      def replace_scenarios
+        evaluation = evaluations_scope.find(params[:id])
+        attributes = scenario_attributes
+        return render json: { errors: [ "No scenarios found in the pasted text" ] }, status: :unprocessable_entity if attributes.empty?
+
+        evaluation.replace_scenarios!(attributes)
+
+        render json: {
+          evaluation: serialize(evaluation.reload),
+          scenarios: evaluation.scenarios.ordered.map(&:as_json_summary),
+          groups: evaluation.scenario_groups
+        }
+      end
+
+      # PATCH /api/evaluations/:id/scenarios/:scenario_id
+      def update_scenario
+        evaluation = evaluations_scope.find(params[:id])
+        scenario = evaluation.scenarios.find(params[:scenario_id])
+        scenario.update!(scenario_params)
+
+        render json: { scenario: scenario.as_json_summary }
+      end
+
+      # DELETE /api/evaluations/:id/scenarios/:scenario_id
+      def destroy_scenario
+        evaluation = evaluations_scope.find(params[:id])
+        evaluation.scenarios.find(params[:scenario_id]).destroy!
+        head :no_content
+      end
+
+      # GET /api/evaluations/:id/runs/:run_id/report?theme=dark
+      #
+      # The run as the framework's self-contained HTML report page — the
+      # in-dashboard view and, because the page is a single file, the export.
+      # `theme` (light|dark) pins the palette to the dashboard's; without it
+      # the page follows the viewer's own preference. The page is served
+      # outside the React app, so its fix item actions link at the absolute
+      # mount path (request.script_name) rather than relative to it.
+      def run_report
+        evaluation = evaluations_scope.find(params[:id])
+        run = evaluation.evaluation_runs.find(params[:run_id])
+        raise ActiveRecord::RecordNotFound unless evaluation.scenario_suite?
+
+        report = run.to_report(links: run.report_links(mount: request.script_name))
+
+        render html: report.to_html(theme: params[:theme]).html_safe, layout: false
+      end
+
       # DELETE /api/evaluations/:id
       def destroy
         evaluations_scope.find(params[:id]).destroy!
@@ -84,14 +189,122 @@ module ActionAgent
 
       private
 
+      # A scenario suite replays through the provider once per scenario and
+      # model, so it runs in the background; a generation-sampling evaluation
+      # scores recorded data and finishes inline.
+      def start_run(evaluation, selection)
+        return evaluation.run_later!(**selection) if evaluation.scenario_suite?
+
+        # EvaluationRunnerService marks the run failed with the error message
+        # and then re-raises. Letting that escape returned an HTML 500 for a
+        # request that had already persisted the evaluation and its failed
+        # run: the client saw a JSON parse error, the form stayed open, and a
+        # resubmit failed on the now-taken name. The failure is on the run
+        # record, which is what the response carries.
+        evaluation.run!
+      rescue StandardError => e
+        Rails.logger.warn(
+          "[ActionAgent] evaluation #{evaluation.id} run failed: #{e.class}: #{e.message}"
+        )
+        # The service records the failure before re-raising; a failure that
+        # predates the run record (creating it, say) is recorded here so the
+        # response always carries one.
+        evaluation.evaluation_runs.recent.first ||
+          evaluation.evaluation_runs.create!(status: :failed, error_message: e.message, completed_at: Time.current)
+      end
+
       def evaluations_scope
         Evaluation.joins(:agent).where(agent: owner_agents)
       end
 
+      def current_evaluation
+        @current_evaluation ||= evaluations_scope.find(params[:id])
+      end
+
+      def requested_agent
+        @requested_agent ||= owner_agents.find(params.require(:evaluation)[:agent_id])
+      end
+
+      # create runs the new evaluation unless told not to.
+      def run_requested?
+        run = params.require(:evaluation)[:run]
+        run != false && run != "false"
+      end
+
+      # Whether this request replays scenarios through the agent: running a
+      # scenario suite, or creating an evaluation with scenarios that runs.
+      def replays_scenarios?
+        case action_name
+        when "run" then current_evaluation.scenario_suite?
+        when "create" then run_requested? && scenario_attributes.any?
+        else false
+        end
+      end
+
+      # Observed agents cannot use the engine's execution service. A persisted
+      # evaluation with an explicit host adapter runs in that source instead.
+      def require_executable_scenario_agent!
+        agent = action_name == "create" ? requested_agent : current_evaluation.agent
+        return unless agent.observed?
+        if action_name == "run"
+          adapter = ActionAgent.scenario_evaluation_adapter_resolver&.call(current_evaluation)
+          return if adapter.respond_to?(:call)
+        end
+
+        render json: {
+          error: "Observed agents are read-only — duplicate this agent to create an executable copy"
+        }, status: :unprocessable_entity
+      end
+
       def evaluation_params
         params.require(:evaluation).permit(:agent_id, :name, :judge_kind, :judge_model, :sample_size)
       end
 
+      def scenario_params
+        params.require(:scenario).permit(:prompt, :group, :notes, :enabled, :key, expectations: {})
+      end
+
+      # scenario_ids, keys, group and models narrow a scenario run. `models`
+      # may arrive as an array or as the comma-separated field the form posts.
+      def selection_params
+        source = params[:evaluation].is_a?(ActionController::Parameters) && params[:evaluation].key?(:selection) ? params[:evaluation][:selection] : params
+        models = source[:models]
+        models = models.to_s.split(",") unless models.is_a?(Array)
+
+        {
+          scenario_ids: Array(source[:scenario_ids]).map(&:to_s).reject(&:blank?),
+          keys: Array(source[:keys]).map(&:to_s).reject(&:blank?),
+          group: source[:group].to_s.presence,
+          models: models.map(&:to_s).map(&:strip).reject(&:blank?)
+        }.compact_blank
+      end
+
+      # Scenarios from text, a YAML/JSON suite, or a list of objects. Production
+      # questions are selected at import time, only on explicit opt-in; the
+      # persisted scenario records do not store an environment flag.
+      def scenario_attributes
+        @scenario_attributes ||= begin
+          source = params[:evaluation].presence || params
+          text = source[:scenarios_text].to_s
+          list = source[:scenarios]
+          include_production_only = ActiveModel::Type::Boolean.new.cast(source[:include_production_only]) == true
+
+          imported = if list.present?
+            list = list.to_unsafe_h.values if list.is_a?(ActionController::Parameters)
+            serialized = Array(list).map { |entry| entry.respond_to?(:to_unsafe_h) ? entry.to_unsafe_h : entry }.to_json
+            ActiveAgent::Evals::ScenarioParser.parse(serialized, include_production_only: include_production_only)
+          elsif text.present?
+            ActiveAgent::Evals::ScenarioParser.parse(text, include_production_only: include_production_only)
+          else
+            []
+          end
+          if (list.present? || text.present?) && imported.empty?
+            raise ActiveAgent::Evals::ScenarioParser::ParseError, "No scenarios matched the import. Check the catalog or include_production_only selection."
+          end
+          imported
+        end
+      end
+
       def normalized_criteria
         explicit_criteria.presence || DEFAULT_CRITERIA.deep_dup
       end
@@ -109,7 +322,9 @@ module ActionAgent
       end
 
       def compare_models_param
-        Array(params[:evaluation][:compare_models]).map(&:to_s).reject(&:blank?)
+        models = params[:evaluation][:compare_models]
+        models = models.to_s.split(",") unless models.is_a?(Array)
+        models.map(&:to_s).map(&:strip).reject(&:blank?)
       end
 
       def serialize(evaluation)
@@ -125,6 +340,9 @@ module ActionAgent
           compare_models: evaluation.compare_models,
           config: evaluation.config,
           sample_size: evaluation.sample_size,
+          scenario_suite: evaluation.scenario_suite?,
+          scenario_count: evaluation.scenarios.size,
+          scenario_groups: evaluation.scenario_suite? ? evaluation.scenario_groups : [],
           created_at: evaluation.created_at.iso8601,
           latest_run: latest ? serialize_run(latest) : nil
         }
@@ -135,14 +353,41 @@ module ActionAgent
           id: run.id,
           status: run.status,
           scores: run.scores,
-          average_score: run.average_score,
+          selection: run.selection,
+          models: run.models,
+          average_score: safe_average_score(run),
           samples_evaluated: run.samples_evaluated,
           samples_passed: run.samples_passed,
+          usage: run.usage,
           error_message: run.error_message,
           completed_at: run.completed_at&.iso8601,
           created_at: run.created_at.iso8601
         }
       end
+
+      # The fix items are derived from every persisted result's diagnosis,
+      # which older runs recorded in earlier shapes; a run they cannot be
+      # built for still serves its results rather than 500-ing the panel.
+      def safe_fix_items(run)
+        run.fix_items
+      rescue StandardError => e
+        Rails.logger.warn(
+          "[ActionAgent] evaluation run #{run.id} fix_items failed: #{e.class}: #{e.message}"
+        )
+        []
+      end
+
+      # index serializes the latest run of every listed evaluation, so an
+      # unaverageable scores payload used to 500 the entire Evaluations page
+      # instead of degrading that one run's headline number.
+      def safe_average_score(run)
+        run.average_score
+      rescue StandardError => e
+        Rails.logger.warn(
+          "[ActionAgent] evaluation run #{run.id} average_score failed: #{e.class}: #{e.message}"
+        )
+        nil
+      end
     end
   end
 end

data/app/controllers/action_agent/api/interaction_messages_controller.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module ActionAgent
+  module Api
+    # Edits to a conversation context from the agent runner: seed a user or
+    # assistant turn without running the agent, fix a turn's text, or drop
+    # one — so the next run sees exactly the history the tester intends.
+    #
+    # Only user and assistant turns are editable. Tool and system rows are
+    # written by execution and read back as call/result pairs; half a pair
+    # is worse than an uneditable one.
+    class InteractionMessagesController < BaseController
+      EDITABLE_ROLES = %w[user assistant].freeze
+
+      # Marks turns typed into the context by hand, as opposed to the
+      # provenance SolidAgent stamps on turns a run produced.
+      MANUAL_PROVENANCE = { "source" => "dashboard", "manual" => true }.freeze
+
+      rescue_from Agent::ObservedAgentError, with: :observed_agent_read_only
+
+      before_action :require_owner!
+      before_action :set_context
+      before_action :require_executable_agent!, only: [ :create, :update, :destroy ]
+      before_action :set_message, only: [ :update, :destroy ]
+
+      # POST /api/interactions/:interaction_id/messages
+      def create
+        role = params[:role].to_s
+        unless EDITABLE_ROLES.include?(role)
+          return render json: { error: "role must be user or assistant" }, status: :unprocessable_entity
+        end
+
+        content = params[:content].to_s
+        return render json: { error: "content can't be blank" }, status: :unprocessable_entity if content.blank?
+
+        message = @context.messages.create!(
+          role: role,
+          content: content,
+          content_checksum: Digest::MD5.hexdigest(content),
+          provenance: MANUAL_PROVENANCE
+        )
+        @context.touch
+
+        render json: { message: AgentMessageSerializer.call(message) }, status: :created
+      end
+
+      # PATCH /api/interactions/:interaction_id/messages/:id
+      def update
+        content = params[:content].to_s
+        return render json: { error: "content can't be blank" }, status: :unprocessable_entity if content.blank?
+
+        @message.update!(content: content, content_checksum: Digest::MD5.hexdigest(content))
+        @context.touch
+
+        render json: { message: AgentMessageSerializer.call(@message) }
+      end
+
+      # DELETE /api/interactions/:interaction_id/messages/:id
+      def destroy
+        @message.destroy!
+        @context.touch
+
+        head :no_content
+      end
+
+      private
+
+      def set_context
+        @context = AgentContext.for_agents(owner_agents).find(params[:interaction_id])
+      end
+
+      # Seeding, fixing or dropping a turn writes the agent's own history, so
+      # it answers to the same read-only policy execution does (#414): an
+      # observed agent is a mirror of someone else's telemetry, and a turn
+      # typed in here would be a fabrication attributed to it. Asked of the
+      # agent rather than re-tested here, so `observed` has one definition and
+      # one message. Reads are left open — every action this controller has is
+      # a write; the conversation itself is still listed and shown.
+      def require_executable_agent!
+        agent = @context.contextable
+        agent.ensure_executable! if agent.respond_to?(:ensure_executable!)
+      end
+
+      def observed_agent_read_only(exception)
+        render json: { error: exception.message }, status: :unprocessable_entity
+      end
+
+      # Looked up through the context, so a message id from another
+      # conversation is a 404 rather than a cross-conversation edit.
+      def set_message
+        @message = @context.messages.find(params[:id])
+        return if EDITABLE_ROLES.include?(@message.role)
+
+        render json: { error: "Only user and assistant messages can be edited" }, status: :unprocessable_entity
+      end
+    end
+  end
+end

data/app/controllers/action_agent/api/mcp_controller.rb

@@ -19,10 +19,10 @@ module ActionAgent
     # Connect from an MCP client with:
     #   { "type": "http", "url": "https://activeagents.ai/mcp",
     #     "headers": { "Authorization": "Bearer aa_..." } }
-    class McpController < BaseController
+    class MCPController < BaseController
       # Authenticated by API key rather than by the host app's sessions.
       allow_unauthenticated_access
-      before_action :authenticate_api_key!
+      before_action :authenticate_api_key!, except: [ :unsupported ]
 
       PROTOCOL_VERSION = "2025-03-26"
       JSONRPC_METHOD_NOT_FOUND = -32601
@@ -51,10 +51,20 @@ module ActionAgent
       rescue McpError => e
         render_error(request_id, e.code, e.message)
       rescue StandardError => e
-        Rails.logger.error("[Api::McpController] #{e.class}: #{e.message}")
+        Rails.logger.error("[Api::MCPController] #{e.class}: #{e.message}")
         render_error(request_id, JSONRPC_SERVER_ERROR, "Internal error")
       end
 
+      # GET (open an SSE stream) and DELETE (end a session) on the endpoint.
+      # Neither is offered: per Streamable HTTP a server that does not
+      # provide a stream MUST answer GET with 405, and an unsupported
+      # session DELETE likewise. Unauthenticated on purpose — a client
+      # probing for the stream should learn "not offered", not "sign in".
+      def unsupported
+        response.headers["Allow"] = "POST"
+        head :method_not_allowed
+      end
+
       private
 
       # JSON-RPC errors ride on HTTP 200 per the MCP Streamable HTTP transport.

data/app/controllers/action_agent/api/mcp_servers_controller.rb

@@ -7,16 +7,16 @@ module ActionAgent
     #
     # The list is the union of three things: servers detected from telemetry
     # and solid_agent records (ToolDiscovery), servers an agent declares in
-    # its configuration, and the default catalog (McpCatalog). An install
+    # its configuration, and the default catalog (MCPCatalog). An install
     # therefore sees both what it is already using and what it could turn on.
-    class McpServersController < BaseController
+    class MCPServersController < BaseController
       before_action :require_owner!
       # Launching provisions a sandbox and runs a server in it, so it answers
       # to the same two gates as any other execution: the read-only kill
       # switch, and whatever limits the host app imposes.
       before_action :require_execution_enabled!, only: [ :launch ]
       before_action :enforce_execution_quota!, only: [ :launch ]
-      before_action :set_catalog_entry, only: [ :show, :launch ]
+      before_action :set_catalog_entry, only: [ :launch ]
 
       STATUS_LABELS = {
         "active" => "Called in this window",
@@ -32,8 +32,8 @@ module ActionAgent
         servers = finder.servers(tools)
 
         render json: {
-          servers: servers,
-          catalog: McpCatalog.all,
+          servers: servers.map { |server| at_mount(server) },
+          catalog: MCPCatalog.all.map { |entry| at_mount(entry) },
           summary: summary_for(servers),
           sandboxes: active_sandboxes,
           window_hours: finder.window_hours,
@@ -45,13 +45,23 @@ module ActionAgent
       #
       # One server with the tools detected for it, so the view can expand a
       # row without refetching the whole inventory.
+      #
+      # The index is a union of detected, declared and catalog servers, and
+      # a server it lists must be fetchable individually — including the
+      # ones the catalog doesn't describe (listed as known: false). Discovery
+      # is consulted first; the catalog is the fallback, and only when
+      # neither knows the key is it a 404.
       def show
         finder = discovery
         tools = finder.detected_tools
-        server = finder.servers(tools).find { |row| row[:key] == params[:id] }
+        server = finder.servers(tools).find { |row| row[:key] == params[:id] } || MCPCatalog.find(params[:id])
+
+        if server.nil?
+          return render json: { error: "Unknown MCP server: #{params[:id]}" }, status: :not_found
+        end
 
         render json: {
-          server: server || @catalog_entry,
+          server: at_mount(server),
           tools: tools.select { |tool| tool[:mcp_server] == params[:id] }
         }
       end
@@ -102,6 +112,16 @@ module ActionAgent
         ToolDiscovery.new(traces: owned_traces, agents: owner_agents, hours: window_hours)
       end
 
+      # The catalog names this dashboard's own MCP endpoint as "<mount>/mcp",
+      # relative to wherever the engine is mounted; only a request knows
+      # where that is. Substituted here, at the edge, so the view shows the
+      # endpoint a client can actually connect to rather than the template.
+      def at_mount(row)
+        return row unless row.is_a?(Hash) && row[:url].is_a?(String) && row[:url].include?("<mount>")
+
+        row.merge(url: row[:url].sub("<mount>", request.script_name.to_s))
+      end
+
       def assign_owner(sandbox, association, record)
         return if record.nil?
         return unless sandbox.respond_to?(:"#{association}=")
@@ -111,7 +131,7 @@ module ActionAgent
       end
 
       def set_catalog_entry
-        @catalog_entry = McpCatalog.find(params[:id])
+        @catalog_entry = MCPCatalog.find(params[:id])
         render json: { error: "Unknown MCP server: #{params[:id]}" }, status: :not_found if @catalog_entry.nil?
       end
 

data/app/controllers/action_agent/api/metrics_controller.rb

@@ -4,17 +4,17 @@ module ActionAgent
   module Api
     # Read API for telemetry metrics, backing the dashboard Metrics view.
     #
-    # Exposes the same aggregates as the gem dashboard's metrics page
+    # Two generations of keys share the response. The legacy keys expose
+    # the same aggregates as the gem dashboard's metrics page
     # (ActionAgent::TracesController#metrics / #calculate_metrics /
-    # #agent_statistics): trace counts, token totals, average duration, error
-    # rate, active agents and per-agent statistics — account-scoped, plus
-    # previous-period deltas for trend indicators.
+    # #agent_statistics): trace counts, token totals, average duration,
+    # error rate, active agents and per-agent statistics — account-scoped,
+    # plus previous-period deltas for trend indicators. The APM keys
+    # (series, totals, deltas, rails, markers) come from MetricsReport and
+    # drive the service-overview layout; see that class for their shape.
     class MetricsController < BaseController
       before_action :require_owner!
 
-      DEFAULT_WINDOW_HOURS = 24
-      MAX_WINDOW_HOURS = 24 * 30
-
       # How to rank the per-agent table. Cost is applied after the grouped
       # query because pricing happens in Ruby (rates vary per model), so all
       # four are ordered in one place rather than half in SQL.
@@ -28,12 +28,34 @@ module ActionAgent
       DEFAULT_AGENT_SORT = "popular"
 
       # GET /api/metrics
+      #
+      # Params:
+      #   range  "1h" | "24h" (default) | "7d" — the APM window and its
+      #          bucket size (MetricsReport::RANGES). A named range also
+      #          sets the legacy window (1, 24 or 168 hours) so both halves
+      #          of the response describe the same period.
+      #   hours  the legacy window; without `range` it makes a "custom"
+      #          range bucketed to about 96 points. Ignored when `range` is
+      #          a known value.
+      #   agent  an agent_class. When given, EVERY key is scoped to that
+      #          agent — the legacy summary, hourly buckets and per-agent
+      #          table included — so the page never shows a filtered chart
+      #          next to an unfiltered tile.
+      #   sort   ranks the legacy per-agent table (AGENT_SORTS).
       def show
-        hours = params.fetch(:hours, DEFAULT_WINDOW_HOURS).to_i.clamp(1, MAX_WINDOW_HOURS)
         now = Time.current
+        report = MetricsReport.new(
+          traces: traces_scope,
+          agents: owner_agents,
+          range: params[:range],
+          hours: params[:hours],
+          agent: agent_filter,
+          now: now
+        )
+        hours = report.window_hours
 
-        current = traces_scope.for_date_range(hours.hours.ago(now), now)
-        previous = traces_scope.for_date_range((hours * 2).hours.ago(now), hours.hours.ago(now))
+        current = legacy_scope.for_date_range(hours.hours.ago(now), now)
+        previous = legacy_scope.for_date_range((hours * 2).hours.ago(now), hours.hours.ago(now))
 
         costs = cost_statistics(current)
         priced = agent_statistics(current).map { |row| row.merge(cost: costs[:by_agent][row[:name]] || 0.0) }
@@ -45,7 +67,7 @@ module ActionAgent
           window_hours: hours,
           sorts: AGENT_SORTS,
           sort: agent_sort(params[:sort])
-        }
+        }.merge(report.to_h)
       end
 
       private
@@ -68,10 +90,21 @@ module ActionAgent
         rows.sort_by { |row| [ -row[key].to_f, -row[:requests].to_i ] }
       end
 
+      def agent_filter
+        params[:agent].presence
+      end
+
+      # Every trace the caller can see — what MetricsReport starts from
+      # (it applies the agent filter itself).
       def traces_scope
         ActionAgent.trace_model.for_account(current_account)
       end
 
+      # The legacy keys' scope: traces_scope narrowed to the filtered agent.
+      def legacy_scope
+        agent_filter ? traces_scope.where(agent_class: agent_filter) : traces_scope
+      end
+
       # Same definitions as the gem dashboard's calculate_metrics, with
       # previous-period percentage changes layered on top.
       def summary_for(current, previous)

data/app/controllers/action_agent/api/provider_models_controller.rb

@@ -74,7 +74,7 @@ module ActionAgent
       # Queries the Anthropic Models API with the account's key (newest first,
       # as returned by the API) so new model releases appear without a deploy.
       def live_anthropic_models
-        key = current_user_provider_key("anthropic")&.credential
+        key = owner_provider_key("anthropic")&.credential
         return nil if key.blank?
 
         data = Rails.cache.fetch("provider_models:anthropic:#{Digest::SHA256.hexdigest(key)}", expires_in: 1.hour) do