actionagent 1.9.6 → 1.9.8

data/app/services/action_agent/mcp_tool_dispatcher.rb

@@ -23,6 +23,12 @@ module ActionAgent
   # is reached the same way (SandboxSession.browser_server_entry), and only
   # this way. Only those keys are taken; a catalog server the agent does not
   # enable stays out of reach.
+  #
+  # A server a dashboard user added on the MCP Services page is enabled as
+  # "custom:<id>" and resolves through MCPServerConfig.server_entry, among the
+  # agent's owner's configurations only and only while it is enabled. Its
+  # client refuses a host that resolves to a non-public address (see
+  # MCPHostGuard) unless the host app allows them.
   class MCPToolDispatcher
     HTTP_TRANSPORTS = %w[http streamable_http sse].freeze
     class SandboxUnavailable < MCPClient::Error; end
@@ -43,6 +49,7 @@ module ActionAgent
     def self.unreachable_reason(entry)
       return "Unknown to the catalog" if entry.nil?
       return nil if SandboxSession.runtime_server_key?(entry[:key].to_s)
+      return "Switched off on the MCP Services page" if entry[:custom] && entry[:enabled] == false
 
       transport = entry[:transport].to_s
       unless transport.in?(HTTP_TRANSPORTS)
@@ -284,14 +291,16 @@ module ActionAgent
     end
 
     # A catalog server, the app runtime of a checkout sandbox the agent's
-    # owner started (keys "sandbox:<session_id>"), or, for a key this run was
-    # given, that sandbox's browser ("browser:<session_id>"). The sandbox
-    # lookups are scoped to the agent's owner, so naming another tenant's
-    # session resolves to nothing.
+    # owner started (keys "sandbox:<session_id>"), a server the agent's owner
+    # added ("custom:<id>"), or, for a key this run was given, that sandbox's
+    # browser ("browser:<session_id>"). The sandbox and custom lookups are
+    # scoped to the agent's owner, so naming another tenant's session or
+    # configuration resolves to nothing.
     def catalog_entry(key)
       if SandboxSession.browser_server_key?(key)
         return extra_server_keys.include?(key) ? SandboxSession.browser_server_entry(key, owner: agent.try(:owner)) : nil
       end
+      return MCPServerConfig.server_entry(key, owner: agent.try(:owner)) if MCPServerConfig.key?(key)
       return MCPCatalog.connection(key) unless SandboxSession.runtime_server_key?(key)
 
       SandboxSession.runtime_server_entry(key, owner: agent.try(:owner))
@@ -303,7 +312,8 @@ module ActionAgent
       @clients[entry[:key]] ||= MCPClient.new(
         url: absolute_url(entry[:url]),
         label: entry[:name] || entry[:key],
-        headers: entry[:headers] || {}
+        headers: entry[:headers] || {},
+        public_only: entry[:public_only] ? true : false
       )
     end
 

data/app/services/action_agent/ollama_host_probe.rb

@@ -10,12 +10,19 @@ module ActionAgent
   # The host is the OpenAI-compatible base URL (".../v1"); the probe calls
   # GET {host}/models. An optional API key is sent as a Bearer token for
   # remote servers behind an authenticating proxy or Ollama Cloud.
+  #
+  # The result says whether the host is Ollama Cloud (`cloud`) and, for
+  # each listed model a price list names, its rate (`rates`): the cloud's
+  # models are metered per token, and a local server's copy of a cloud
+  # model is priced at the same list rate (ModelPricing). A model priced
+  # only by a guess has no entry.
   class OllamaHostProbe
     TIMEOUT_SECONDS = 4
+    CLOUD_HOST = "ollama.com"
 
-    Result = Struct.new(:ok, :host, :models, :latency_ms, :error, keyword_init: true) do
+    Result = Struct.new(:ok, :host, :models, :latency_ms, :error, :cloud, :rates, keyword_init: true) do
       def to_h
-        { ok: ok, host: host, models: models, latency_ms: latency_ms, error: error }
+        { ok: ok, host: host, models: models, latency_ms: latency_ms, error: error, cloud: cloud, rates: rates }
       end
     end
 
@@ -23,11 +30,24 @@ module ActionAgent
       new(host: host, api_key: api_key).call
     end
 
+    # Whether +host+ addresses Ollama Cloud (the framework's
+    # ActiveAgent::Providers::Ollama::Cloud.cloud_host?, kept in step).
+    def self.cloud_host?(host)
+      name = URI.parse(host.to_s.strip).host.to_s.downcase
+      name == CLOUD_HOST || name.end_with?(".#{CLOUD_HOST}")
+    rescue URI::InvalidURIError
+      false
+    end
+
     def initialize(host:, api_key: nil)
       @host = ProviderKey.normalize_host(host)
       @api_key = api_key.presence
     end
 
+    def cloud?
+      self.class.cloud_host?(@host)
+    end
+
     def call
       return failure("No host configured") if @host.blank?
 
@@ -49,7 +69,7 @@ module ActionAgent
 
       data = JSON.parse(response.body)
       models = Array(data["data"]).filter_map { |model| model["id"] }.sort
-      Result.new(ok: true, host: @host, models: models, latency_ms: latency_ms, error: nil)
+      Result.new(ok: true, host: @host, models: models, latency_ms: latency_ms, error: nil, cloud: cloud?, rates: rates_for(models))
     rescue JSON::ParserError
       failure("#{@host} did not return JSON — is this the OpenAI-compatible /v1 endpoint?")
     rescue URI::InvalidURIError, ArgumentError
@@ -68,8 +88,20 @@ module ActionAgent
       @api_key ? { "Authorization" => "Bearer #{@api_key}" } : {}
     end
 
+    # `{ "gpt-oss:120b" => { input: 0.15, output: 0.6, source: "catalog" } }`
+    # for every listed model a price list names, in $ per million tokens.
+    def rates_for(models)
+      provider = cloud? ? ModelPricing::OLLAMA_CLOUD_PROVIDER : "ollama"
+      models.each_with_object({}) do |id, rates|
+        detail = ModelPricing.rate_detail(id, provider: provider)
+        next if ModelPricing::FALLBACK_SOURCES.include?(detail[:source])
+
+        rates[id] = detail.slice(:input, :output, :source)
+      end
+    end
+
     def failure(message, latency_ms = nil)
-      Result.new(ok: false, host: @host, models: [], latency_ms: latency_ms, error: message)
+      Result.new(ok: false, host: @host, models: [], latency_ms: latency_ms, error: message, cloud: cloud?, rates: {})
     end
   end
 end

data/app/services/action_agent/scenario_catalog_import.rb

@@ -181,6 +181,10 @@ module ActionAgent
           metadata: entry.metadata, agent: resolve_agent(entry) || (merge? ? product.agent : nil),
           project: resolve_project(entry) || (merge? ? product.project : nil)
         )
+        # Until add_catalog_product_criteria runs, imports keep working without the lists.
+        product.criteria = entry.criteria if product.has_attribute?(:criteria)
+        # Until add_catalog_pass_bars runs, imports keep working without the bars.
+        product.pass = entry.pass if product.has_attribute?(:pass)
         product.position = position_for(product, entry.position, offset)
         product.save!
         replace_sets(product, entry)
@@ -197,6 +201,7 @@ module ActionAgent
           name: set_entry.name, description: set_entry.description, judge: set_entry.judge,
           criteria: set_entry.criteria, metadata: set_entry.metadata
         )
+        set.pass = set_entry.pass if set.has_attribute?(:pass)
         set.position = position_for(set, set_entry.position, offset)
         set.save!
         replace_scenarios(set, set_entry)
@@ -213,6 +218,8 @@ module ActionAgent
           prompt: scenario.prompt, notes: scenario.notes, expectations: scenario.expectations,
           tags: scenario.tags, params: scenario.params, production_only: scenario.production_only?
         )
+        # Until add_catalog_scenario_metadata runs, imports keep working without extensions.
+        record.metadata = scenario.metadata if record.has_attribute?(:metadata)
         record.position = position_for(record, scenario.position, offset)
         record.save!
       end

data/app/services/action_agent/scenario_evaluation_runner.rb

@@ -22,6 +22,11 @@ module ActionAgent
   #                        decisive (ActiveAgent::Evals::Comparison)
   #   "_selection"       — the scenarios and models this run covered, and
   #                        the checkout sandbox it replayed against, if any
+  #   "_pass_thresholds" — for an evaluation of a catalog set that declares
+  #                        `pass` bars: the bars, recorded as the run starts,
+  #                        so every replay and the completion gate by the same
+  #                        ones however the catalog changes meanwhile
+  #   "_gates"           — with them: each group's gate per model, met or not
   #
   # A selection's `sandbox_id` names a checkout sandbox whose app runtime
   # every replay reaches beside the agent's own MCP servers, as if the agent
@@ -41,6 +46,7 @@ module ActionAgent
   # any replay, and one started here is stopped once the run ends.
   class ScenarioEvaluationRunner < EvaluationRunnerService
     Evals = ActiveAgent::Evals
+    JUDGE_LEASE_DURATION = 30.minutes
 
     # The providers a candidate model name resolves against. `mock` is the
     # framework's test double, accepted so the test suite can compare cohorts
@@ -80,6 +86,7 @@ module ActionAgent
       specs = model_specs
       run = @run || @evaluation.evaluation_runs.create!(status: :pending)
       run.update!(status: :running, selection: selection_summary(scenarios, specs))
+      record_pass_thresholds!(run)
       ensure_sandbox_live!
 
       if scenarios.empty?
@@ -124,7 +131,7 @@ module ActionAgent
         adapter.call(evaluation: @evaluation, owner: owner, scenarios: tasks, models: specs, on_result: metered)
       else
         ensure_judge_defined_kpis! if @evaluation.judge_defined?
-        default_report(tasks, specs, on_result)
+        default_report(tasks, specs, on_result, run)
       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 ] }
@@ -187,17 +194,20 @@ module ActionAgent
     # A job delivered again for a result that is already scored, or that a
     # concurrent delivery has claimed, scores nothing. It still checks
     # whether the run is complete: the earlier delivery may have stored the
-    # last result and stopped before completing the run.
+    # last result and stopped before completing the run. A result another
+    # delivery holds a live lease on is tried again when the lease expires
+    # (see #wait_for_claim!).
     def judge_result!(row)
       run = row.evaluation_run
       return unless run.running?
-      return finish_fan_out!(run) unless row.pending? && claim_result!(row)
+      return finish_fan_out!(run) unless row.pending?
+      return wait_for_claim!(row, run) unless claim_result!(row)
 
       spec = fan_out_specs(run).fetch([ row.provider.to_s, row.model ]) do
         Evals::ModelSpec.new(label: row.model, provider: row.provider.to_s, model: row.model)
       end
       result = fan_out_scorer(run).evaluate(Evals::Scenario.from_hash(row.evaluated_scenario), spec, replay_from(row))
-      row.update!(
+      store_claimed_result!(row,
         status: result.status,
         score: result.score,
         scores: result.scores,
@@ -227,7 +237,15 @@ module ActionAgent
           row = stored_result(run, scenario, spec)
           task = Evals::Scenario.from_hash(scenario.as_json_summary)
           row ||= store_replay(run, scenario, task, spec, Evals::Replay.failed(error))
-          row.update!(status: :errored, error_message: row.error_message.presence || error_text(error)) if row.pending?
+          attributes = { status: :errored, error_message: row.error_message.presence || error_text(error) }
+          if scoring_leases?
+            # Another replay delivery may fail while this result is being
+            # scored. Only an unclaimed replay belongs to this failure path.
+            EvaluationScenarioResult.where(id: row.id, status: :pending, scoring_token: nil)
+              .update_all(attributes.merge(updated_at: Time.current))
+          elsif row.pending?
+            row.update!(attributes)
+          end
         end
       end
       finish_fan_out!(run)
@@ -237,7 +255,7 @@ module ActionAgent
     # still completes.
     def fail_judging!(row, error)
       run = row.evaluation_run
-      row.update!(status: :errored, error_message: [ row.error_message.presence, "Scoring failed: #{error_text(error)}" ].compact.join(" ")) if row.pending?
+      store_claimed_result!(row, status: :errored, error_message: [ row.error_message.presence, "Scoring failed: #{error_text(error)}" ].compact.join(" ")) if row.pending?
       finish_fan_out!(run)
     end
 
@@ -331,15 +349,59 @@ module ActionAgent
       @evaluation.scenarios.where(id: ids).count * specs.size
     end
 
-    # Claims a pending result for this job before it is scored. Of two judge
-    # jobs delivered for one result (a replay job delivered again after it
-    # enqueued the first), only the one whose claim lands scores it, so the
-    # judge is asked once and the run's meter counts each call once. The
-    # claim is a conditional write on the row's timestamp: it holds no lock
-    # while the judge is asked, and a row whose claimant then stops is still
-    # pending for the next delivery.
+    # A timestamp comparison alone only rejects a stale reader. A duplicate
+    # delivered after that write reads the new timestamp and could score too.
+    # The lease excludes fresh readers as well, without holding a database
+    # lock across a provider call. A redelivery can reclaim an expired lease.
+    #
+    # Without the lease columns (migration 030 not yet run) the claim is the
+    # timestamp comparison alone, as before the lease.
     def claim_result!(row)
-      EvaluationScenarioResult.where(id: row.id, status: :pending, updated_at: row.updated_at).update_all(updated_at: Time.current) == 1
+      now = Time.current
+      claim = EvaluationScenarioResult.where(id: row.id, status: :pending, updated_at: row.updated_at)
+      return claim.update_all(updated_at: now) == 1 unless scoring_leases?
+
+      token = SecureRandom.uuid
+      claimed = claim.where("scoring_token IS NULL OR scoring_expires_at <= ?", now)
+        .update_all(scoring_token: token, scoring_expires_at: now + JUDGE_LEASE_DURATION, updated_at: now)
+      @scoring_token = token if claimed == 1
+    end
+
+    # A claim lost to another delivery leaves the result pending, and that
+    # delivery may be a worker that stopped: the queue's redelivery of its
+    # job lands here, inside the lease the stopped worker still holds. So the
+    # job is enqueued again for when that lease expires. If the holder stores
+    # the result first, the later delivery finds it scored and only checks
+    # whether the run is complete. A result left pending with no live lease
+    # (the claim raced another write to the row) is tried again at once.
+    # Without the lease columns a lost claim is a concurrent delivery that is
+    # scoring the result now, as before.
+    def wait_for_claim!(row, run)
+      current = EvaluationScenarioResult.find_by(id: row.id) if scoring_leases?
+      if current&.pending?
+        retry_at = [ current.scoring_expires_at, Time.current ].compact.max
+        EvaluationJudgeJob.set(wait_until: retry_at).perform_later(row.id, @selection.to_h, run.id)
+      end
+      finish_fan_out!(run)
+    end
+
+    # Fence late successes and failures: after a lease is reclaimed, the old
+    # worker cannot overwrite its successor. Only the current owner releases
+    # the lease. A failure before claiming may mark an unclaimed row errored.
+    def store_claimed_result!(row, **attributes)
+      return row.update!(attributes) unless scoring_leases?
+
+      row.assign_attributes(attributes)
+      row.validate!
+      EvaluationScenarioResult.where(id: row.id, status: :pending, scoring_token: @scoring_token)
+        .update_all(attributes.merge(scoring_token: nil, scoring_expires_at: nil, updated_at: Time.current))
+    end
+
+    # Whether migration 030's lease columns are installed. A host that
+    # upgraded the gem without running the generator keeps scoring with the
+    # timestamp claim instead of failing every judge job on a missing column.
+    def scoring_leases?
+      (%w[scoring_token scoring_expires_at] - EvaluationScenarioResult.column_names).empty?
     end
 
     # What Evals::Runner does with a replay that raises: an errored replay,
@@ -397,7 +459,7 @@ module ActionAgent
         available_tools: fan_out_state(run).fetch("tools") { tool_roster },
         instructions: @evaluation.agent.instructions,
         agent_name: @evaluation.agent.name,
-        threshold: PASS_THRESHOLD,
+        **gating(run.pass_thresholds, Evals::Runner),
         replay: ->(*) { raise ArgumentError, "a fanned-out result is scored from its stored replay" },
         refine_gate: -> { reserve_refinement!(run) }
       )
@@ -457,7 +519,7 @@ module ActionAgent
         )
       end
       report = Evals::Report.new(results: results, models: specs.values, judge: evals_judge,
-                                 instructions: @evaluation.agent.instructions, threshold: PASS_THRESHOLD)
+                                 instructions: @evaluation.agent.instructions, **gating(run.pass_thresholds, Evals::Report))
       state = fan_out_state(run)
 
       # The other jobs' judge calls go into this runner's meter before the
@@ -503,7 +565,7 @@ module ActionAgent
       error.is_a?(Exception) ? "#{error.class}: #{error.message}" : error.to_s
     end
 
-    def default_report(tasks, specs, on_result)
+    def default_report(tasks, specs, on_result, run)
       Evals::Runner.new(
         scenarios: tasks,
         models: specs,
@@ -512,7 +574,7 @@ module ActionAgent
         available_tools: tool_roster,
         instructions: @evaluation.agent.instructions,
         agent_name: @evaluation.agent.name,
-        threshold: PASS_THRESHOLD,
+        **gating(run.pass_thresholds, Evals::Runner),
         replay: ->(scenario, spec) { replay(scenario, spec) },
         on_result: on_result
       ).call
@@ -771,6 +833,7 @@ module ActionAgent
       comparison = report.comparison if report.respond_to?(:comparison)
       scores["_comparison"] = comparison if comparison
       scores["_selection"] = run.selection
+      record_gates(scores, report, run.pass_thresholds)
       scores["_metadata"] = report.metadata
       scores["_judge_label"] = report.judge_label || report.judge&.label
       # The judge's own spend, apart from the replays' (which the results
@@ -783,6 +846,60 @@ module ActionAgent
       scores
     end
 
+    # The bars a host adapter's report did not carry are the run's own, so
+    # the run is gated however its replays ran.
+    def record_gates(scores, report, recorded)
+      thresholds = (report.pass_thresholds if report.respond_to?(:pass_thresholds)) || recorded
+      return if thresholds.nil?
+
+      scores["_pass_thresholds"] = thresholds.to_h
+      scores["_gates"] = report.gates(thresholds).map(&:to_h)
+    end
+
+    # --- pass bars ----------------------------------------------------------
+
+    # The score keyword, and the bars when the run has them and the
+    # installed framework's +klass+ takes them: the bars' threshold is the
+    # catalog's or PASS_THRESHOLD, the score the dashboard always used.
+    def gating(thresholds, klass)
+      return { threshold: PASS_THRESHOLD } if thresholds.nil? || !accepts_keyword?(klass, :pass_thresholds)
+
+      { threshold: thresholds.threshold, pass_thresholds: thresholds }
+    end
+
+    def accepts_keyword?(klass, keyword)
+      klass.instance_method(:initialize).parameters.any? { |type, name| name == keyword && %i[key keyreq].include?(type) }
+    end
+
+    # Records the bars of the catalog set this evaluation runs as, once,
+    # as the run starts: a fanned-out replay reads them from the run.
+    def record_pass_thresholds!(run)
+      thresholds = catalog_pass_thresholds
+      return if thresholds.nil?
+
+      run.update!(scores: (run.scores.is_a?(Hash) ? run.scores : {}).merge("_pass_thresholds" => thresholds.to_h))
+    end
+
+    # The product's bars as the suite's and the set's as its group's, as
+    # Catalog#suite_for gives them, for an evaluation a catalog set
+    # materialized (ScenarioSet#catalog_reference) when the set, under the
+    # owner's catalogs, still has the keys the reference names; nil when
+    # it declares none, and on a framework without per-group bars.
+    def catalog_pass_thresholds
+      reference = @evaluation.config.to_h["catalog"]
+      return nil unless reference.is_a?(Hash) && defined?(Evals::PassThresholds)
+
+      set = ScenarioSet.joins(:product).includes(:product)
+        .where(ScenarioProduct.table_name => { scenario_catalog_id: ScenarioCatalog.for_owner(owner).select(:id) })
+        .find_by(id: reference["set_id"], key: reference["set_key"].to_s)
+      return nil if set.nil? || set.product.key != reference["product_key"].to_s
+      return nil if set.product.pass.empty? && set.pass.empty?
+
+      Evals::PassThresholds.new(suite: set.product.pass, groups: { set.key => set.pass })
+    rescue ArgumentError
+      nil
+    end
+
     # Records who judged once the calls are in. A judge with no model pinned
     # started out labelled by its provider; it is renamed after the model
     # that answered, here and on the verdict it wrote.

data/app/services/action_agent/tool_discovery.rb

@@ -37,7 +37,9 @@ module ActionAgent
   # rules (single-user, per-user, or multi-tenant) decide what is visible.
   # The same goes for checkout sandbox runtimes: the caller hands in the live
   # ones it may see (SandboxSession.runtime_server_listings), and they are
-  # listed beside the catalog under their "sandbox:<session_id>" keys.
+  # listed beside the catalog under their "sandbox:<session_id>" keys. The
+  # servers the owner added (MCPServerConfig.listings) are handed in the same
+  # way, under their "custom:<id>" keys.
   class ToolDiscovery
     DEFAULT_WINDOW_HOURS = 24 * 7
     MAX_WINDOW_HOURS = 24 * 90
@@ -543,6 +545,8 @@ module ActionAgent
         # from traffic is real but undocumented here, and the view says so.
         known: !catalog.nil?,
         runtime: runtime,
+        # A server the owner added on the MCP Services page ("custom:<id>").
+        custom: MCPServerConfig.key?(key),
         status: server_status(calls, configured, catalog),
         calls: calls,
         errors: bucket ? bucket[:errors] : 0,

data/config/routes.rb

@@ -193,6 +193,12 @@ ActionAgent::Engine.routes.draw do
       end
     end
 
+    # The caller's own remote MCP servers, enabled on agents as
+    # "custom:<id>". Header values are write-only; test runs tools/list.
+    resources :mcp_server_configs, only: [ :index, :create, :update, :destroy ] do
+      post :test, on: :member
+    end
+
     resources :instance_tiers, only: [ :index, :show ] do
       collection do
         get :recommend

data/lib/action_agent/engine.rb

@@ -1,5 +1,12 @@
 # frozen_string_literal: true
 
+# The class body below reads Zeitwerk's inflector. Rails requires Zeitwerk
+# only when an application sets up its autoloaders, which is after
+# Bundler.require has loaded this file; a host that reaches it earlier does so
+# by chance (Action Cable's engine loads it as a side effect). So the constant
+# has to come from here. Zeitwerk is a dependency of Active Support, so it is
+# always installed.
+require "zeitwerk"
 require_relative "assistant_request_filter"
 
 module ActionAgent
@@ -25,7 +32,10 @@ module ActionAgent
       "mcp_tool_dispatcher" => "MCPToolDispatcher",
       "mcp_controller" => "MCPController",
       "mcp_dashboard_tools" => "MCPDashboardTools",
+      "mcp_host_guard" => "MCPHostGuard",
       "mcp_recording_middleware" => "MCPRecordingMiddleware",
+      "mcp_server_config" => "MCPServerConfig",
+      "mcp_server_configs_controller" => "MCPServerConfigsController",
       "mcp_servers_controller" => "MCPServersController",
       "playwright_mcp_client" => "PlaywrightMCPClient"
     }.freeze

data/lib/action_agent/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActionAgent
-  VERSION = "1.9.6"
+  VERSION = "1.9.8"
 end

data/lib/action_agent.rb

@@ -887,6 +887,22 @@ module ActionAgent
     # @return [Array<Hash>]
     attr_accessor :mcp_catalog
 
+    # Whether a dashboard user's own MCP server (MCPServerConfig, added on the
+    # MCP Services page) may point at a loopback, private, link-local or
+    # otherwise non-public address. Off by default: those servers are reached
+    # from the dashboard's own network, so a URL such as
+    # http://169.254.169.254/ or http://10.0.0.5/admin would let any user make
+    # the dashboard call an address only it can reach. MCPHostGuard refuses
+    # such a URL when it is saved, and refuses a host name that resolves to
+    # one when it is called. Turn it on for local development, where the
+    # server under test runs on localhost, or for a single-user install whose
+    # user already has that network access.
+    #
+    # Host registrations (+mcp_catalog+) and checkout sandbox runtimes are the
+    # host app's own configuration and are not affected.
+    # @return [Boolean]
+    attr_accessor :allow_private_mcp_hosts
+
     # Host-declared ActiveAgent::SchemaTools subclasses whose generated tools
     # are offered alongside AgentToolbox's built-ins: each generated tool is
     # individually selectable in the agent editor, dispatched by name at
@@ -1358,6 +1374,7 @@ module ActionAgent
       @user_menu_links = nil
       @sign_in_path = nil
       @mcp_catalog = []
+      @allow_private_mcp_hosts = false
       @agent_actor_resolver = nil
       @schema_tools = nil
       @schema_tools_path = "app/agent_tools"

data/lib/generators/action_agent/templates/action_agent.rb.erb

@@ -317,6 +317,17 @@ ActionAgent.configure do |config|
   # Expired sandboxes are stopped by `bin/rails action_agent:sandbox:reap`.
   # Schedule it every few minutes.
 
+  # ==========================================================================
+  # MCP servers
+  # ==========================================================================
+  #
+  # Users add their own remote MCP servers on the MCP Services page. Their
+  # URLs may not reach a loopback, private or link-local address unless this
+  # is on: those servers are called from the dashboard's own network. Turn it
+  # on in development to test a server running on localhost.
+  #
+  # config.allow_private_mcp_hosts = Rails.env.development?
+
   # ==========================================================================
   # UI
   # ==========================================================================

data/lib/generators/action_agent/templates/migrations/030_add_evaluation_scoring_leases.rb.erb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class AddEvaluationScoringLeases < ActiveRecord::Migration<%= migration_version %>
+  def change
+    add_column "#{ActionAgent.table_name_prefix}evaluation_scenario_results", :scoring_token, :string
+    add_column "#{ActionAgent.table_name_prefix}evaluation_scenario_results", :scoring_expires_at, :datetime
+  end
+end

data/lib/generators/action_agent/templates/migrations/031_add_catalog_scenario_metadata.rb.erb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class AddCatalogScenarioMetadata < ActiveRecord::Migration<%= migration_version %>
+  def up
+    return unless table_exists?(scenarios_table)
+    return if column_exists?(scenarios_table, :metadata)
+
+    type = connection.adapter_name.to_s.downcase.include?("postgres") ? :jsonb : :json
+    add_column scenarios_table, :metadata, type
+  end
+
+  def down
+    return unless table_exists?(scenarios_table)
+    return unless column_exists?(scenarios_table, :metadata)
+
+    remove_column scenarios_table, :metadata
+  end
+
+  private
+
+  def scenarios_table
+    "#{ActionAgent.table_name_prefix}catalog_scenarios"
+  end
+end

data/lib/generators/action_agent/templates/migrations/032_create_active_agent_mcp_server_configs.rb.erb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# MCP servers a dashboard user adds on the MCP Services page
+# (ActionAgent::MCPServerConfig): a remote server's URL, its request headers
+# (encrypted at rest, in secret_headers), and what the last connection test
+# found. Each row belongs to an account or a user, as provider keys do.
+#
+# Table names follow ActionAgent.table_name_prefix, and JSON columns are
+# jsonb on PostgreSQL and json elsewhere, the same way as
+# create_active_agent_dashboard_tables.
+class CreateActiveAgentMCPServerConfigs < ActiveRecord::Migration<%= migration_version %>
+  def change
+    prefix = ActionAgent.table_name_prefix
+
+    create_table "#{prefix}mcp_server_configs" do |t|
+      t.string :name, null: false
+      t.text :description
+      t.string :url, null: false, limit: 2048
+      # A JSON object of header name => value, encrypted.
+      t.text :secret_headers
+      t.boolean :enabled, null: false, default: true
+      t.datetime :last_tested_at
+      # "ok" or "failed", and the error of a failed test.
+      t.string :last_test_status
+      t.text :last_test_error
+      # The tool names the last successful test listed.
+      t.column :tool_names, json_type, **json_default([])
+      t.bigint :account_id
+      t.bigint :user_id
+      t.timestamps
+      t.index :account_id, name: "index_#{prefix}mcp_server_configs_on_account"
+      t.index :user_id, name: "index_#{prefix}mcp_server_configs_on_user"
+    end
+  end
+
+  private
+
+  def json_type
+    @json_type ||= postgres? ? :jsonb : :json
+  end
+
+  # MySQL rejects a default on a JSON column outright, so the column is
+  # created without one there.
+  def json_default(value, null: nil)
+    return {} unless postgres?
+
+    null.nil? ? { default: value } : { default: value, null: null }
+  end
+
+  def postgres?
+    connection.adapter_name.to_s.downcase.include?("postgres")
+  end
+end

data/lib/generators/action_agent/templates/migrations/034_add_catalog_product_criteria.rb.erb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class AddCatalogProductCriteria < ActiveRecord::Migration<%= migration_version %>
+  def up
+    return unless table_exists?(products_table)
+    return if column_exists?(products_table, :criteria)
+
+    type = connection.adapter_name.to_s.downcase.include?("postgres") ? :jsonb : :json
+    add_column products_table, :criteria, type
+  end
+
+  def down
+    return unless table_exists?(products_table)
+    return unless column_exists?(products_table, :criteria)
+
+    remove_column products_table, :criteria
+  end
+
+  private
+
+  def products_table
+    "#{ActionAgent.table_name_prefix}scenario_products"
+  end
+end