actionagent 1.2.2 → 1.5.0

data/app/services/action_agent/playwright_mcp_client.rb

@@ -1,20 +1,10 @@
 # frozen_string_literal: true
 
 module ActionAgent
-  require "net/http"
-  require "resolv"
-
-  # Minimal MCP client (streamable HTTP transport) for a Playwright MCP
-  # server — typically `npx @playwright/mcp --port 8931` running beside the
-  # app in development, or a sandbox-provisioned browser container in
-  # production. Speaks just enough JSON-RPC for tools/call: initialize once
-  # per process, then call tools under the session id the server hands back.
-  class PlaywrightMcpClient
+  # The Playwright MCP server as one configured MCPClient: a process-wide
+  # instance pointed at the url PLAYWRIGHT_MCP_URL names.
+  class PlaywrightMCPClient < MCPClient
     DEFAULT_URL = ENV.fetch("PLAYWRIGHT_MCP_URL", "http://host.orb.internal:8931/mcp")
-    OPEN_TIMEOUT_SECONDS = 5
-    READ_TIMEOUT_SECONDS = 60
-
-    class Error < StandardError; end
 
     def self.instance
       @instance ||= new
@@ -25,124 +15,19 @@ module ActionAgent
     end
 
     def initialize(url: DEFAULT_URL)
-      @uri = URI(url)
-      @mutex = Mutex.new
+      super(url: url, label: "Playwright")
     end
 
-    # Returns { text:, is_error: } — the tool result's text content.
+    # Restarting the shared instance on an unreachable server is this
+    # subclass's concern: the next call re-initializes rather than reusing a
+    # session the server has forgotten. The message names the local fix.
     def call_tool(name, arguments = {})
-      Rails.logger.debug("[PlaywrightMcpClient] call #{name} args=#{arguments.inspect[0, 200]}")
-      ensure_session!
-      response = post(
-        { jsonrpc: "2.0", id: next_id, method: "tools/call",
-          params: { name: name, arguments: arguments } },
-        session: @session_id
-      )
-      result = response["result"]
-      unless result
-        Rails.logger.warn("[PlaywrightMcpClient] #{name} unexpected response: #{response.inspect[0, 500]}")
-        raise Error, (response.dig("error", "message") || "empty MCP response")
-      end
-
-      text = Array(result["content"]).filter_map { |block| block["text"] }.join("\n")
-      { text: text, is_error: result["isError"] ? true : false }
-    rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Net::OpenTimeout, SocketError => e
+      super
+    rescue MCPClient::Error => e
       self.class.reset!
-      raise Error, "Playwright MCP server unreachable at #{@uri} (#{e.class}): start it with `npx @playwright/mcp --port 8931`"
-    end
-
-    private
-
-    def ensure_session!
-      @mutex.synchronize do
-        next if @session_id
-
-        _body, response = post_raw(
-          { jsonrpc: "2.0", id: next_id, method: "initialize",
-            params: { protocolVersion: "2025-03-26", capabilities: {},
-                      clientInfo: { name: "activeagents", version: "1.0" } } }
-        )
-        @session_id = response["mcp-session-id"]
-        raise Error, "MCP server did not return a session id" unless @session_id
-
-        post({ jsonrpc: "2.0", method: "notifications/initialized" }, session: @session_id)
-      end
-    end
-
-    def post(payload, session: nil)
-      body, _response = post_raw(payload, session: session)
-      body
-    end
-
-    def post_raw(payload, session: nil)
-      # Tool calls run inside the provider SDK's streaming enumerator — a
-      # fiber, where Net::HTTP reads of SSE bodies misbehave (headers arrive,
-      # body comes back empty). A dedicated thread always does real blocking
-      # IO outside any fiber/scheduler context.
-      Thread.new { blocking_post_raw(payload, session: session) }.value
-    end
-
-    def blocking_post_raw(payload, session: nil)
-      http = Net::HTTP.new(@uri.host, @uri.port)
-      # Container->host bridge hostnames (host.orb.internal) publish an IPv6
-      # address whose path doesn't reach the server; dual-stack connects then
-      # fail intermittently. Pin to IPv4 while keeping the Host header.
-      if (ipv4 = ipv4_address)
-        http.ipaddr = ipv4
-      end
-      http.open_timeout = OPEN_TIMEOUT_SECONDS
-      http.read_timeout = READ_TIMEOUT_SECONDS
-      request = Net::HTTP::Post.new(@uri.request_uri)
-      request["Content-Type"] = "application/json"
-      request["Accept"] = "application/json, text/event-stream"
-      request["Mcp-Session-Id"] = session if session
-      request.body = payload.to_json
-
-      response = http.request(request)
-      Rails.logger.debug(
-        "[PlaywrightMcpClient] #{payload[:method]} -> #{response.code} " \
-        "ct=#{response['Content-Type']} bytes=#{response.body.to_s.bytesize} session=#{session ? 'yes' : 'no'}"
-      )
-      unless response.code.to_i.between?(200, 299)
-        Rails.logger.warn("[PlaywrightMcpClient] HTTP #{response.code}: #{response.body.to_s[0, 300]}")
-        raise Error, "MCP server returned HTTP #{response.code}"
-      end
-
-      parsed = parse_body(response)
-      if parsed.empty? && payload[:id]
-        Rails.logger.warn("[PlaywrightMcpClient] unparsed body (#{response['Content-Type']}): #{response.body.to_s[0, 500]}")
-      end
-      [ parsed, response ]
-    end
-
-    # Streamable HTTP answers as plain JSON or as an SSE stream whose data:
-    # lines carry the JSON-RPC response — accept both.
-    def parse_body(response)
-      body = response.body.to_s
-      return {} if body.empty?
-
-      if response["Content-Type"].to_s.include?("text/event-stream")
-        body.lines
-            .select { |line| line.start_with?("data:") }
-            .filter_map { |line| JSON.parse(line.delete_prefix("data:").strip) rescue nil }
-            .find { |json| json["result"] || json["error"] } || {}
-      else
-        JSON.parse(body)
-      end
-    rescue JSON::ParserError
-      {}
-    end
-
-    def ipv4_address
-      return @ipv4_address if defined?(@ipv4_address)
-
-      @ipv4_address = Resolv.getaddresses(@uri.host).find { |address| address =~ Resolv::IPv4::Regex }
-    rescue Resolv::ResolvError
-      @ipv4_address = nil
-    end
+      raise Error, "#{e.message}: start it with `npx @playwright/mcp --port 8931`" if e.message.include?("unreachable")
 
-    def next_id
-      @id = (@id || 0) + 1
+      raise
     end
   end
 end

data/app/services/action_agent/sandbox_orchestrator.rb

@@ -52,7 +52,18 @@ module ActionAgent
     # as sandbox_service, falling back to the in-memory one.
     def self.default_backend
       name = ENV["SANDBOX_BACKEND"].presence || ActionAgent.sandbox_service.to_s
-      backends.key?(name) ? name : "mock"
+      return name if backends.key?(name)
+
+      # Substituting the mock silently made a misconfigured operator's
+      # sandbox "runs" succeed against nothing real.
+      if name.present? && name != "mock"
+        Rails.logger.warn(
+          "[ActionAgent] sandbox backend #{name.inspect} is not registered " \
+          "(ActionAgent.sandbox_backends knows #{backends.keys.inspect}); " \
+          "using the in-memory mock backend, which runs nothing."
+        )
+      end
+      "mock"
     end
 
     def initialize(backend: nil)

data/app/services/action_agent/scenario_evaluation_runner.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+module ActionAgent
+  # Runs a scenario evaluation: replays every selected scenario through the
+  # agent once per candidate model and writes one EvaluationScenarioResult per
+  # scenario × model plus a per-model summary and verdict on the run.
+  #
+  # The scoring, fault diagnosis and roll-up are ActiveAgent::Evals'; this
+  # class supplies what only the dashboard knows — how to run the agent
+  # (Agent#test_execute with a model override), where to persist each result,
+  # how to price tokens, and which judge model the owner has credentials for.
+  #
+  # The run's `scores` keep the shape the Evaluations UI renders — criterion
+  # => stats, or criterion => { model => stats } when comparing — and add
+  # underscore-prefixed summaries:
+  #
+  #   "_models"          — per model: pass rate, mean score, latency, tokens, cost, fault counts
+  #   "_recommendations" — faults grouped across scenarios with the fix each calls for
+  #   "_verdict"         — the best model and why (judge-written when a judge is available)
+  #   "_selection"       — the scenarios and models this run covered
+  class ScenarioEvaluationRunner < EvaluationRunnerService
+    Evals = ActiveAgent::Evals
+
+    # `run` is an EvaluationRun created ahead of time (by run_later!, so the
+    # UI can show it pending while the job waits); absent, one is created here.
+    def self.call(evaluation, selection: {}, run: nil)
+      new(evaluation, selection: selection, run: run).call
+    end
+
+    def initialize(evaluation, selection: {}, run: nil)
+      super(evaluation)
+      @selection = (selection || {}).to_h.with_indifferent_access
+      @run = run
+    end
+
+    def call
+      scenarios = selected_scenarios
+      specs = model_specs
+      run = @run || @evaluation.evaluation_runs.create!(status: :pending)
+      run.update!(status: :running, selection: selection_summary(scenarios, specs))
+
+      if scenarios.empty?
+        run.update!(status: :failed, error_message: "No scenarios selected — add scenarios to the evaluation or widen the selection",
+          completed_at: Time.current)
+        return run
+      end
+
+      records = scenarios.index_by(&:key)
+      tasks = scenarios.map { |scenario| Evals::Scenario.from_hash(scenario.as_json_summary) }
+      expected = tasks.product(specs).map { |task, spec| [ task.key, spec.label ] }
+      # Every result tests membership twice, so look the pairs up in a set;
+      # `expected` stays an array for the completeness comparison below, and
+      # `persisted` sorts the same way either way.
+      allowed = expected.to_set
+      persisted = Set.new
+      on_result = lambda do |result|
+        pair = [ result.scenario.key, result.label ]
+        raise ArgumentError, "unexpected or duplicate scenario evaluation result" unless allowed.include?(pair) && !persisted.include?(pair)
+
+        persist(run, records.fetch(result.scenario.key), result)
+        persisted << pair
+      end
+      adapter = ActionAgent.scenario_evaluation_adapter_resolver&.call(@evaluation)
+      report = if adapter
+        raise ArgumentError, "scenario evaluation adapter must be callable" unless adapter.respond_to?(:call)
+
+        adapter.call(evaluation: @evaluation, owner: owner, scenarios: tasks, models: specs, on_result: on_result)
+      else
+        ensure_judge_defined_kpis! if @evaluation.judge_defined?
+        default_report(tasks, specs, on_result)
+      end
+      raise ArgumentError, "scenario evaluation adapter must return an ActiveAgent::Evals::Report" unless report.is_a?(Evals::Report)
+      reported = report.results.map { |result| [ result.scenario.key, result.label ] }
+      unless reported.sort == expected.sort && persisted.sort == expected.sort
+        raise ArgumentError, "scenario evaluation adapter must report and persist every selected scenario and model"
+      end
+
+      run.update!(
+        status: :complete,
+        scores: scores_for(report, run),
+        samples_evaluated: report.results.size,
+        samples_passed: report.results.count(&:passed?),
+        completed_at: Time.current
+      )
+      run
+    rescue StandardError => e
+      run&.update!(status: :failed, error_message: e.message, completed_at: Time.current)
+      raise
+    end
+
+    private
+
+    def default_report(tasks, specs, on_result)
+      Evals::Runner.new(
+        scenarios: tasks,
+        models: specs,
+        criteria: sample_criteria,
+        judge: evals_judge,
+        available_tools: tool_roster,
+        instructions: @evaluation.agent.instructions,
+        agent_name: @evaluation.agent.name,
+        threshold: PASS_THRESHOLD,
+        replay: ->(scenario, spec) { replay(scenario, spec) },
+        on_result: on_result
+      ).call
+    end
+
+    # --- selection --------------------------------------------------------
+
+    def selected_scenarios
+      scope = @evaluation.scenarios.enabled.ordered
+      scope = scope.where(id: Array(@selection[:scenario_ids])) if @selection[:scenario_ids].present?
+      scope = scope.where(key: Array(@selection[:keys])) if @selection[:keys].present?
+      scope = scope.in_group(@selection[:group]) if @selection[:group].present?
+      scope.to_a
+    end
+
+    # The models to compare: an explicit selection, else the evaluation's
+    # compare_models, else the agent as configured. `mock` is the framework's
+    # test double, accepted so the test suite can compare cohorts offline.
+    def model_specs
+      names = Array(@selection[:models]).presence || @evaluation.compare_models
+      specs = Evals::ModelSpec.parse_all(names, default_provider: @evaluation.agent.provider, providers: Agent::PROVIDERS + %w[mock])
+      return specs if specs.any?
+
+      [ Evals::ModelSpec.new(label: @evaluation.agent.model, provider: @evaluation.agent.provider, model: @evaluation.agent.model) ]
+    end
+
+    def selection_summary(scenarios, specs)
+      {
+        "scenario_ids" => scenarios.map(&:id),
+        "scenario_keys" => scenarios.map(&:key),
+        "group" => @selection[:group].presence,
+        "models" => specs.map(&:to_h)
+      }.compact
+    end
+
+    # --- replay -----------------------------------------------------------
+
+    def replay(scenario, spec)
+      # One execution per replay, reported to the host before the run starts
+      # (the order SandboxesController#compare uses), so it is counted even
+      # when the run fails.
+      ActionAgent.record_usage(owner, :execution)
+
+      agent_run = @evaluation.agent.test_execute(
+        scenario.prompt,
+        model_override: spec.model,
+        provider_override: spec.provider
+      )
+
+      Evals::Replay.new(
+        answer: agent_run.output,
+        tool_calls: tool_calls_for(agent_run),
+        duration_ms: agent_run.calculated_duration_ms,
+        input_tokens: agent_run.input_tokens,
+        output_tokens: agent_run.output_tokens,
+        error: agent_run.failed? ? agent_run.error_message.presence || "run failed" : nil,
+        cost: ModelPricing.estimate(model: spec.model, input_tokens: agent_run.input_tokens, output_tokens: agent_run.output_tokens),
+        metadata: { "agent_run_id" => agent_run.id }
+      )
+    end
+
+    # Each tool call the run made, rebuilt from the run's progress events
+    # (AgentRun#append_event pairs a "started" event with its "done"/"error"
+    # by eid). Falls back to the bare names in the run's metadata for a run
+    # recorded without events.
+    def tool_calls_for(agent_run)
+      events = Array(agent_run.logs).select { |event| event.is_a?(Hash) && %w[tool agent].include?(event["kind"]) }
+      if events.empty?
+        return Array(agent_run.output_metadata&.dig("tool_calls")).map { |name| { "name" => name.to_s } }
+      end
+
+      events.group_by { |event| event["eid"] }.values.map do |group|
+        started = group.find { |event| event["status"] == "started" }
+        finished = group.find { |event| %w[done error].include?(event["status"]) }
+        label = (started || finished)["label"].to_s
+
+        {
+          "name" => label.sub(/\s*→.*\z/, ""),
+          "arguments" => parse_json(started&.dig("detail")),
+          "error" => finished&.dig("status") == "error",
+          "detail" => finished&.dig("detail"),
+          "duration_ms" => finished&.dig("duration_ms")
+        }.compact
+      end
+    end
+
+    def parse_json(text)
+      return nil if text.blank?
+
+      JSON.parse(text)
+    rescue JSON::ParserError
+      text
+    end
+
+    # --- persistence ------------------------------------------------------
+
+    def persist(run, scenario, result)
+      run.scenario_results.create!(
+        scenario: scenario,
+        agent_run_id: result.replay.metadata["agent_run_id"],
+        model: result.model,
+        provider: result.provider,
+        status: result.status,
+        score: result.score,
+        scores: result.scores,
+        output: result.replay.answer.to_s.byteslice(0, 20_000).to_s.scrub.presence,
+        tool_calls: result.replay.tool_calls,
+        duration_ms: result.replay.duration_ms,
+        input_tokens: result.replay.input_tokens,
+        output_tokens: result.replay.output_tokens,
+        cost: result.replay.cost,
+        fault: result.fault,
+        recommendation: result.recommendation,
+        diagnosis: (result.diagnosis || {}).merge(
+          "_replay_metadata" => result.replay.metadata,
+          "_scenario_snapshot" => result.scenario.to_h.merge(expectations: result.scenario.expectations)
+        ),
+        error_message: result.replay.error
+      )
+    end
+
+    def scores_for(report, run)
+      scores = report.criterion_scores
+      scores["_models"] = report.summary_by_model
+      scores["_recommendations"] = report.recommendations
+      scores["_verdict"] = report.verdict if report.comparing?
+      scores["_selection"] = run.selection
+      scores["_metadata"] = report.metadata
+      scores["_judge_label"] = report.judge_label || report.judge&.label
+      scores
+    end
+
+    # --- judge ------------------------------------------------------------
+
+    def sample_criteria
+      @sample_criteria ||= @evaluation.criteria.reject do |criterion|
+        Evaluation::TELEMETRY_CRITERION_TYPES.include?(criterion["type"])
+      end
+    end
+
+    def tool_roster
+      @tool_roster ||= AgentToolbox.definitions_for(@evaluation.agent.tools).to_h do |definition|
+        [ definition[:name].to_s, definition[:description].to_s ]
+      end
+    end
+
+    # The judge the evaluation's owner has credentials for, wrapped for the
+    # evaluation core; nil when none is configured, in which case scoring
+    # stays on rules and expectations.
+    def evals_judge
+      return nil unless judge_available?
+
+      @evals_judge ||= Evals::Judge.new(label: @evaluation.judge_model.presence || judge_provider.to_s) do |instructions:, prompt:|
+        judge_class.prompt(message: prompt, instructions: instructions).generate_now.message&.content
+      end
+    end
+  end
+end

data/app/services/action_agent/tool_discovery.rb

@@ -30,7 +30,7 @@ module ActionAgent
   #
   # MCP attribution comes from ActiveAgent::Telemetry::ToolOrigin (the
   # +mcp__server__tool+ convention, tagged onto spans at instrumentation
-  # time), then McpCatalog's hints for bare tool names, then the tool is
+  # time), then MCPCatalog's hints for bare tool names, then the tool is
   # treated as a method the agent class defines.
   #
   # Scopes are passed in rather than derived, so the caller's ownership
@@ -259,7 +259,7 @@ module ActionAgent
           end
         end
 
-        Array(agent.mcp_servers).each do |server|
+        configured_mcp_servers(agent).each do |server|
           key = mcp_server_key(server)
           next if key.blank?
 
@@ -404,7 +404,7 @@ module ActionAgent
       classification = ActiveAgent::Telemetry::ToolOrigin.classify(name)
       return { origin: ORIGIN_MCP, server: classification[:server] } if classification[:server].present?
 
-      if (hinted = McpCatalog.server_for_tool(name))
+      if (hinted = MCPCatalog.server_for_tool(name))
         # A catalog hint is weaker evidence than a namespaced name: the tool
         # is *probably* this server's, but a builtin of the same name is the
         # dashboard's own implementation, so builtins win the tie.
@@ -474,7 +474,7 @@ module ActionAgent
 
     def source_label(origin, server)
       case origin
-      when ORIGIN_MCP then server.present? ? "MCP · #{McpCatalog.display_name(server)}" : "MCP"
+      when ORIGIN_MCP then server.present? ? "MCP · #{MCPCatalog.display_name(server)}" : "MCP"
       when ORIGIN_BUILTIN then "Dashboard toolbox"
       else "Agent-defined"
       end
@@ -500,7 +500,7 @@ module ActionAgent
         end
       end
 
-      keys = (McpCatalog::BY_KEY.keys + detected.keys + configured_servers.keys).uniq
+      keys = (MCPCatalog.keys + detected.keys + configured_servers.keys).uniq
 
       # detected has a default block that would materialize a bucket on
       # lookup, so unseen servers are passed through as an explicit nil.
@@ -509,7 +509,7 @@ module ActionAgent
     end
 
     def server_row(key, bucket)
-      catalog = McpCatalog.find(key)
+      catalog = MCPCatalog.find(key)
       configured = configured_servers[key].to_a.sort
       calls = bucket ? bucket[:calls] : 0
 
@@ -559,11 +559,25 @@ module ActionAgent
       @configured_servers ||= Hash.new { |hash, key| hash[key] = Set.new }
     end
 
+    # The servers an agent declares, as a list. Agents store an Array, but
+    # an agent created from an older template seed carried a top-level Hash
+    # keyed by server name ({"playwright" => {"command" => ...}}); Array()
+    # turned that into [key, value] pairs and the key lookup below raised
+    # TypeError on the Array, taking down /api/tools and /api/mcp_servers
+    # for the whole workspace.
+    def configured_mcp_servers(agent)
+      servers = agent.mcp_servers
+      return servers.keys if servers.is_a?(Hash)
+
+      Array(servers)
+    end
+
     # An agent's mcp_servers entries are free-form: a bare string name, or a
     # hash from the builder ({"name" => "playwright", "url" => ...}).
+    # Anything else (a stray Array, a number) is skipped rather than raised on.
     def mcp_server_key(server)
-      return server.to_s.strip if server.is_a?(String)
-      return nil unless server.respond_to?(:[])
+      return server.to_s.strip.presence if server.is_a?(String) || server.is_a?(Symbol)
+      return nil unless server.respond_to?(:key?)
 
       (server["key"] || server[:key] || server["name"] || server[:name]).to_s.strip.presence
     end

data/config/routes.rb

@@ -20,6 +20,8 @@ ActionAgent::Engine.routes.draw do
 
   # The dashboard's own JSON API, read and written by the React app.
   namespace :api do
+    resource :dashboard_assistant, only: [ :show, :create ], controller: "dashboard_assistant"
+
     # Telemetry ingestion, relative to wherever the engine is mounted:
     # <mount>/api/traces (e.g. /activeagents/api/traces at the default mount).
     # Authenticated with a bearer token, not a session.
@@ -36,6 +38,10 @@ ActionAgent::Engine.routes.draw do
         post :duplicate
         get :export
         get :analytics
+        # The runner's conversation picker: this agent's persisted contexts,
+        # and a fresh one to pin a first message to.
+        get :conversations
+        post :conversations, action: :create_conversation
       end
       collection do
         get :presets
@@ -70,7 +76,7 @@ ActionAgent::Engine.routes.draw do
     resources :tools, only: [ :index ]
 
     # MCP services — detected servers unioned with the default catalog
-    # (McpCatalog), plus on-demand sandbox provisioning. Keys are catalog
+    # (MCPCatalog), plus on-demand sandbox provisioning. Keys are catalog
     # slugs like "sequential-thinking", so the id segment allows dashes.
     resources :mcp_servers, only: [ :index, :show ], id: /[^\/]+/ do
       member do
@@ -111,12 +117,23 @@ ActionAgent::Engine.routes.draw do
     resource :metrics, only: [ :show ], controller: "metrics"
 
     # Conversations (contexts, messages, generations) behind Interactions.
-    resources :interactions, only: [ :index, :show ]
+    # The runner edits a conversation in place — seeds, fixes or drops a
+    # turn — so the next run sees exactly the history it should.
+    resources :interactions, only: [ :index, :show ] do
+      resources :messages, only: [ :create, :update, :destroy ], controller: "interaction_messages"
+    end
 
-    # Agent output evaluations.
+    # Agent output evaluations. A scenario suite also manages its scenarios
+    # here, and exposes each run's per-scenario, per-model results.
     resources :evaluations, only: [ :index, :show, :create, :destroy ] do
       member do
         post :run
+        get "runs/:run_id", action: :show_run, as: :run_result
+        get "runs/:run_id/report", action: :run_report, as: :run_report
+        get :scenarios
+        put :scenarios, action: :replace_scenarios
+        patch "scenarios/:scenario_id", action: :update_scenario, as: :scenario
+        delete "scenarios/:scenario_id", action: :destroy_scenario
       end
     end
 
@@ -128,6 +145,12 @@ ActionAgent::Engine.routes.draw do
     # Model catalogs for the agent builder (Ollama queried live from the
     # configured host; hosted providers curated).
     resources :provider_models, only: [ :index ]
+
+    # The plan meter the Organization view and the Run Agents quota banner
+    # read. The engine meters nothing itself: a host that tracks usage
+    # against a plan answers through ActionAgent.usage_resolver, and a bare
+    # mount reports unlimited rather than 404.
+    resource :usage, only: [ :show ], controller: "usage"
   end
 
   # The account's agents presented as an authenticated MCP server (tools +
@@ -136,6 +159,16 @@ ActionAgent::Engine.routes.draw do
   # namespace's session-authenticated controllers.
   post "mcp", to: "api/mcp#create"
 
+  # MCP Streamable HTTP (2025-03-26): a client MAY open the server-to-client
+  # SSE stream with GET, and ends a session with DELETE. This facade offers
+  # no stream and keeps no sessions, so both answer 405 with Allow: POST —
+  # the clean "not offered" signal SDK clients expect, instead of the
+  # dashboard's HTML page parsed as an event stream. A browser's GET (Accept
+  # prefers HTML) is the MCP Services view's deep link, and falls through to
+  # the catch-all below like any other client-side route.
+  match "mcp", to: "api/mcp#unsupported", via: [ :get, :delete ],
+    constraints: ->(request) { request.delete? || !ActionAgent::Engine.html_request?(request) }
+
   # Everything else under the mount is a client-side route: render the
   # dashboard and let the browser resolve it. Anchored last so it can only
   # ever catch what the routes above did not, and refuses /api paths so a

data/lib/action_agent/assistant_request_filter.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ActionAgent
+  # Runs before Rails' request logger, including for requests later rejected by
+  # authentication, consent or CSRF. Match the endpoint under any engine mount;
+  # leave the host application's unrelated message/history parameters alone.
+  class AssistantRequestFilter
+    PATH = %r{/api/dashboard_assistant(?:\.[^/]+)?/?\z}
+    PARAMETERS = [ /\Amessage\z/i, /\Ahistory\z/i ].freeze
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      if PATH.match?(env["PATH_INFO"].to_s)
+        env["action_dispatch.parameter_filter"] = Array(env["action_dispatch.parameter_filter"]) + PARAMETERS
+      end
+      @app.call(env)
+    end
+  end
+end