actionagent 1.9.6 → 1.9.7

data/app/models/action_agent/mcp_server_config.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+module ActionAgent
+  # A remote MCP server a dashboard user added on the MCP Services page, so
+  # their agents can call a server neither the built-in catalog nor the host
+  # app's ActionAgent.mcp_catalog lists: their own app's MCP endpoint, say.
+  #
+  # An agent enables one under its key, "custom:<id>", the way it enables a
+  # catalog server under its slug. MCPToolDispatcher resolves the key among
+  # the agent's owner's configurations only (.server_entry), so naming
+  # another owner's id reaches nothing, and an agent run or a scenario
+  # evaluation run calls its tools like a catalog server's.
+  #
+  # The server is reached over Streamable HTTP at +url+. Request headers
+  # (an Authorization header, an API key header) are kept in +secret_headers+,
+  # a JSON object encrypted at rest with the provider keys. Their values are
+  # never rendered back to the browser: #header_hints names each header with
+  # a masked value, and #assign_headers keeps a header's stored value when
+  # an update leaves it blank.
+  #
+  # The URL may not reach a non-public address unless the host app sets
+  # ActionAgent.allow_private_mcp_hosts (see MCPHostGuard). A disabled
+  # configuration stays listed but is not dispatched to.
+  class MCPServerConfig < ApplicationRecord
+    include Ownable
+    owned_by :account, :user
+
+    # The key an agent's mcp_servers names a configuration by.
+    KEY_PREFIX = "custom:"
+    KEY_PATTERN = /\Acustom:(\d+)\z/
+
+    MAX_HEADERS = 20
+    MAX_HEADER_VALUE_LENGTH = 4096
+    # An HTTP header field name (RFC 9110 token).
+    HEADER_NAME = /\A[!#$%&'*+\-.^_`|~0-9A-Za-z]+\z/
+    # Headers MCPClient sets itself, which a configuration cannot replace
+    # without breaking the protocol it speaks.
+    RESERVED_HEADERS = %w[accept content-type content-length host mcp-session-id user-agent connection transfer-encoding].freeze
+    # How many tool names a test records.
+    MAX_TOOL_NAMES = 500
+
+    TEST_OK = "ok"
+    TEST_FAILED = "failed"
+
+    encrypts :secret_headers if ActionAgent.encrypt_credentials
+
+    validates :name, presence: true, length: { maximum: 100 }
+    validates :url, presence: true, length: { maximum: 2048 }
+    validate :url_is_reachable_address
+    validate :headers_are_valid
+
+    scope :enabled, -> { where(enabled: true) }
+
+    class << self
+      # Whether +key+ names a configuration ("custom:<id>").
+      def key?(key)
+        KEY_PATTERN.match?(key.to_s.strip)
+      end
+
+      # The configuration +key+ names, looked up among +owner+'s only, or nil.
+      #
+      # @param key [String]
+      # @param owner [Object, nil] the agent's owner
+      # @return [MCPServerConfig, nil]
+      def find_by_key(key, owner:)
+        id = key.to_s.strip[KEY_PATTERN, 1] or return nil
+
+        for_owner(owner).find_by(id: id)
+      end
+
+      # The connection MCPToolDispatcher calls, headers included, for the
+      # configuration +key+ names among +owner+'s. Nil when there is none or
+      # it is disabled.
+      #
+      # @return [Hash, nil]
+      def server_entry(key, owner:)
+        find_by_key(key, owner: owner)&.server_entry
+      end
+
+      # The configurations in +scope+ (a relation already scoped to an owner)
+      # as MCP server listings: the catalog entry shape MCPCatalog serves,
+      # without headers. ToolDiscovery and AgentToolRoster list them beside
+      # the catalog, as they list checkout runtimes.
+      #
+      # @return [Array<Hash>]
+      def listings(scope)
+        scope.order(:name, :id).map(&:listing)
+      end
+    end
+
+    def server_key
+      "#{KEY_PREFIX}#{id}"
+    end
+
+    # The request headers, name => value. Empty when none are set or the
+    # stored value is not a JSON object.
+    #
+    # @return [Hash{String => String}]
+    def headers
+      parsed = JSON.parse(secret_headers.presence || "{}")
+      parsed.is_a?(Hash) ? parsed.transform_values(&:to_s) : {}
+    rescue JSON::ParserError
+      {}
+    end
+
+    def headers=(value)
+      self.secret_headers = value.to_h.transform_keys(&:to_s).transform_values(&:to_s).to_json
+    end
+
+    # Replaces the headers with +submitted+, a list of { name, value } pairs.
+    # A header submitted with a blank value keeps the value stored under the
+    # same name (compared without case); a header left out is removed. A new
+    # header with a blank value is kept blank, so validation refuses it.
+    #
+    # @param submitted [Array<Hash>]
+    def assign_headers(submitted)
+      stored = headers.transform_keys(&:downcase)
+
+      self.headers = Array(submitted).each_with_object({}) do |header, kept|
+        header = header.to_h.stringify_keys
+        name = header["name"].to_s.strip
+        next if name.blank?
+
+        value = header["value"].to_s
+        kept[name] = value.strip.empty? ? stored[name.downcase].to_s : value
+      end
+    end
+
+    # Each header's name with a masked value, for the browser.
+    #
+    # @return [Array<Hash>] +{ name:, hint: }+
+    def header_hints
+      headers.map { |name, value| { name: name, hint: mask(value) } }
+    end
+
+    # Every header value, for scrubbing from recorded output.
+    def secret_values
+      headers.values.reject(&:blank?)
+    end
+
+    # The connection MCPToolDispatcher calls, headers included, or nil when
+    # the configuration is disabled. Never serialized to the browser.
+    #
+    # @return [Hash, nil]
+    def server_entry
+      return nil unless enabled?
+
+      listing.merge(url: url, headers: headers, public_only: !MCPHostGuard.allow_private?)
+    end
+
+    # This configuration as a header-free MCP server listing.
+    #
+    # @return [Hash]
+    def listing
+      {
+        key: server_key,
+        name: name,
+        description: description.presence || "Your MCP server at #{display_url}",
+        transport: "streamable_http",
+        url: display_url,
+        command: nil, package: nil, categories: [ "custom" ], docs_url: nil,
+        sandbox: false, sandbox_type: nil, first_party: false,
+        requires_credentials: [], tools: tool_names_list,
+        custom: true, enabled: enabled?
+      }
+    end
+
+    # The tool names the last successful test discovered.
+    #
+    # @return [Array<String>]
+    def tool_names_list
+      Array(tool_names).map(&:to_s)
+    end
+
+    # Calls tools/list on the server and records the outcome: the discovered
+    # tool names on success, the error on failure. Uses the configuration as
+    # it stands, saved or not, and saves it only when it is persisted.
+    #
+    # @param client [MCPClient, nil] the client to call, for tests
+    # @return [Hash] +{ ok:, tools:, error:, latency_ms: }+
+    def test_connection!(client: nil)
+      started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      client ||= MCPClient.new(url: url, label: name, headers: headers, public_only: !MCPHostGuard.allow_private?)
+      names = client.list_tools.filter_map { |tool| (tool[:name] || tool["name"]).to_s.presence }.uniq.first(MAX_TOOL_NAMES)
+      record_test(TEST_OK, tools: names)
+      { ok: true, tools: names, error: nil, latency_ms: elapsed_ms(started) }
+    rescue MCPClient::Error, URI::Error => e
+      record_test(TEST_FAILED, error: e.message)
+      { ok: false, tools: tool_names_list, error: e.message, latency_ms: elapsed_ms(started) }
+    end
+
+    # The configuration for the browser: never a header value.
+    #
+    # @return [Hash]
+    def as_api_json
+      {
+        id: id,
+        key: server_key,
+        name: name,
+        description: description,
+        url: url,
+        enabled: enabled?,
+        headers: header_hints,
+        tools: tool_names_list,
+        last_tested_at: last_tested_at&.iso8601,
+        last_test_status: last_test_status,
+        last_test_error: last_test_error,
+        updated_at: updated_at&.iso8601
+      }
+    end
+
+    private
+
+    # The URL without its query string, which can carry a token.
+    def display_url
+      uri = URI.parse(url.to_s)
+      uri.query = nil
+      uri.fragment = nil
+      uri.to_s
+    rescue URI::InvalidURIError
+      url.to_s
+    end
+
+    def record_test(status, tools: nil, error: nil)
+      self.last_tested_at = Time.current
+      self.last_test_status = status
+      self.last_test_error = error.to_s.first(1000).presence
+      self.tool_names = tools unless tools.nil?
+      save!(validate: false) if persisted?
+    end
+
+    def elapsed_ms(started)
+      ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000).round
+    end
+
+    # "••••a1b2" for a long value, "••••" for a short one, whose last
+    # characters would give away too much of it.
+    def mask(value)
+      value.to_s.length >= 16 ? "••••#{value.to_s.last(4)}" : "••••"
+    end
+
+    def url_is_reachable_address
+      return if url.blank?
+
+      reason = MCPHostGuard.url_refusal(url)
+      errors.add(:url, reason) if reason
+    end
+
+    def headers_are_valid
+      current = headers
+      errors.add(:headers, "can hold at most #{MAX_HEADERS} entries") if current.size > MAX_HEADERS
+
+      seen = Set.new
+      current.each do |name, value|
+        if !HEADER_NAME.match?(name)
+          errors.add(:headers, "#{name.inspect} is not a valid header name")
+        elsif RESERVED_HEADERS.include?(name.downcase)
+          errors.add(:headers, "#{name} is set by the MCP client and cannot be replaced")
+        elsif !seen.add?(name.downcase)
+          errors.add(:headers, "#{name} is listed twice")
+        end
+
+        if value.strip.empty?
+          errors.add(:headers, "#{name} needs a value")
+        elsif value.length > MAX_HEADER_VALUE_LENGTH
+          errors.add(:headers, "#{name} is longer than #{MAX_HEADER_VALUE_LENGTH} characters")
+        elsif value.match?(/[\r\n\0]/)
+          errors.add(:headers, "#{name} must not contain line breaks")
+        end
+      end
+    end
+  end
+end

data/app/models/action_agent/model_pricing.rb

@@ -10,10 +10,15 @@ module ActionAgent
   # Rates come from RubyLLM's model registry (USD per million tokens,
   # maintained upstream per model) when the model is known there — looked
   # up under the provider it ran on when the caller knows it, since
-  # `gpt-5.5` through OpenRouter and `gpt-5.5` at OpenAI are two entries.
-  # The static tables below are the fallback for aliases, self-hosted
-  # models and an install without RubyLLM: exact rows (STATIC_RATES) for
-  # the current frontier models, then name patterns (PRICES), then a
+  # `gpt-5.5` through OpenRouter and `gpt-5.5` at OpenAI are two entries,
+  # and `deepseek-v4-flash` through Ollama Cloud is priced by Ollama, not
+  # by DeepSeek. A model run under Ollama is looked up in the registry's
+  # Ollama Cloud listing by the name the cloud uses, whichever way it was
+  # spelled (`gpt-oss:120b-cloud` through a local server is the cloud's
+  # `gpt-oss:120b`). The static tables below are the fallback for aliases,
+  # self-hosted models and an install without RubyLLM: exact rows
+  # (STATIC_RATES) for the current frontier models and Ollama Cloud's own
+  # price list (OLLAMA_CLOUD_RATES), then name patterns (PRICES), then a
   # conservative blended rate so totals stay meaningful. Costs are always
   # presented as estimates, and every rate says where it came from
   # (`source`), so a figure worked out at a fallback rate can say so.
@@ -35,6 +40,37 @@ module ActionAgent
       "gpt-5-nano" => [ 0.05, 0.40 ]
     }.freeze
 
+    # Ollama Cloud's price list, by the name the cloud lists each model
+    # under: USD per million input and output tokens. The rows RubyLLM's
+    # registry carries under its `ollama_cloud` provider (RubyLLM 2.1.1,
+    # from models.dev), copied on 2026-10-30 for an install without the
+    # gem; DeepSeek's rows are its off-peak rates. A model the cloud lists
+    # at no price yet is left out, so it prices as any other Ollama model.
+    OLLAMA_CLOUD_RATES = {
+      "deepseek-v4-flash" => [ 0.22, 0.66 ],
+      "deepseek-v4-flash:0731" => [ 0.22, 0.66 ],
+      "deepseek-v4-pro" => [ 0.66, 1.98 ],
+      "deepseek-v4-pro:0813" => [ 0.66, 1.98 ],
+      "deepseek-v4.1-flash" => [ 0.15, 0.60 ],
+      "gemma4:31b" => [ 0.14, 0.40 ],
+      "glm-5.1" => [ 1.00, 3.20 ],
+      "glm-5.2" => [ 1.40, 4.40 ],
+      "glm-5.3" => [ 1.40, 4.40 ],
+      "glm-5.3-flash" => [ 0.15, 0.50 ],
+      "gpt-oss:120b" => [ 0.15, 0.60 ],
+      "gpt-oss:20b" => [ 0.07, 0.30 ],
+      "kimi-k2.6" => [ 0.95, 4.00 ],
+      "kimi-k2.7-code" => [ 0.95, 4.00 ],
+      "kimi-k3" => [ 3.00, 15.00 ],
+      "minimax-m2.7" => [ 0.30, 1.20 ],
+      "minimax-m3" => [ 0.60, 2.40 ],
+      "mistral-large-3:675b" => [ 0.50, 1.50 ],
+      "nemotron-3-nano:30b" => [ 0.06, 0.24 ],
+      "nemotron-3-super" => [ 0.015, 0.60 ],
+      "nemotron-3-ultra" => [ 0.10, 3.00 ],
+      "qwen3.5:397b" => [ 0.60, 3.60 ]
+    }.freeze
+
     PRICES = [
       # [pattern, input $/1M, output $/1M]
       [ /gpt-4o-mini/i, 0.15, 0.60 ],
@@ -65,10 +101,12 @@ module ActionAgent
     # Fallback blended rate for unknown models ($/1M input, $/1M output)
     DEFAULT_RATE = [ 1.00, 4.00 ].freeze
 
-    # Where a rate came from: RubyLLM's bundled catalog, a registry the host
-    # keeps itself (RubyLLM's model table or a refreshed listing), a row of
-    # STATIC_RATES or PRICES, or DEFAULT_RATE. The last two are a guess at
-    # the model's price rather than its listing.
+    # Where a rate came from: a listing of the model — RubyLLM's bundled
+    # catalog, or Ollama Cloud's price list bundled here (`catalog`), or a
+    # registry the host keeps itself, RubyLLM's model table or a refreshed
+    # listing (`remote`) — else a row of STATIC_RATES or PRICES, or
+    # DEFAULT_RATE. The last two are a guess at the model's price rather
+    # than its listing.
     SOURCES = %w[catalog remote pattern default].freeze
     FALLBACK_SOURCES = %w[pattern default].freeze
 
@@ -83,6 +121,22 @@ module ActionAgent
       "qwen" => nil, "x-ai" => "xai", "xai" => "xai", "cohere" => nil, "perplexity" => "perplexity"
     }.freeze
 
+    # Provider names as the registry spells them, for the ones a trace's
+    # `llm.provider` tag ("OpenAI::Chat", "Ollama") or a run's provider key
+    # ("open_router") spells otherwise once downcased and cut at "::".
+    PROVIDER_SLUGS = {
+      "open_router" => "openrouter", "open_ai" => "openai", "ollama-cloud" => "ollama_cloud",
+      "azure_openai" => "azure", "azureopenai" => "azure", "azure_open_ai" => "azure"
+    }.freeze
+
+    # The registry's provider for Ollama Cloud's listing, which prices a
+    # model run under Ollama whichever route served it.
+    OLLAMA_CLOUD_PROVIDER = "ollama_cloud"
+    OLLAMA_PROVIDERS = [ "ollama", OLLAMA_CLOUD_PROVIDER ].freeze
+    # A local Ollama server's spellings of a cloud model: the framework's
+    # ActiveAgent::Providers::Ollama::Cloud, kept in step.
+    OLLAMA_CLOUD_MARKERS = %w[-cloud :cloud].freeze
+
     class << self
       # @return [Float, nil] estimated USD cost, nil when there is nothing to price
       def estimate(model:, input_tokens:, output_tokens:, provider: nil)
@@ -119,11 +173,12 @@ module ActionAgent
       def rate_detail(model, provider: nil)
         return { input: DEFAULT_RATE[0], output: DEFAULT_RATE[1], source: "default" } if model.blank?
 
-        key = [ provider.to_s, model.to_s ]
+        slug = provider_slug(provider)
+        key = [ slug.to_s, model.to_s ]
         @rates ||= {}
         return @rates[key] if @rates.key?(key)
 
-        @rates[key] = registry_rate(model.to_s, provider.to_s.presence) || static_rate(model.to_s)
+        @rates[key] = registry_rate(model.to_s, slug) || static_rate(model.to_s, slug)
       end
 
       # Forgets memoized rates — after RubyLLM is loaded, or in tests.
@@ -136,27 +191,65 @@ module ActionAgent
       # and the version of the registry the install has (or none).
       def fingerprint
         registry = defined?(::RubyLLM) && ::RubyLLM.const_defined?(:VERSION) ? ::RubyLLM::VERSION.to_s : "none"
-        tables = [ STATIC_RATES, PRICES.map { |pattern, input, output| [ pattern.source, input, output ] }, DEFAULT_RATE, registry ]
+        tables = [
+          STATIC_RATES, OLLAMA_CLOUD_RATES, PRICES.map { |pattern, input, output| [ pattern.source, input, output ] },
+          DEFAULT_RATE, registry
+        ]
         Digest::SHA256.hexdigest(JSON.generate(tables))[0, 12]
       end
 
-      # "openrouter/anthropic/claude-sonnet-4-5-20250929" → "claude-sonnet-4-5":
-      # the name without a gateway or vendor prefix, a date suffix or a
-      # colon-tagged size, with dots as dashes, so the same model under two
-      # spellings keys one row.
+      # "openrouter/anthropic/claude-sonnet-4-5-20250929" → "claude-sonnet-4-5",
+      # "gpt-oss:120b-cloud" → "gpt-oss:120b": the name without a gateway or
+      # vendor prefix, a date suffix, a colon-tagged size or a local Ollama
+      # server's cloud marker, with dots as dashes, so the same model under
+      # two spellings keys one row.
       def normalize(model)
-        name = model.to_s.strip.downcase
+        name = ollama_canonical(model.to_s.strip.downcase)
         name = name.split("/").last.to_s
         name = name.sub(/-\d{8}\z/, "").sub(/-\d{4}-\d{2}-\d{2}\z/, "")
         name.tr(".", "-")
       end
 
+      # The provider as the registry names it, from how a trace or a run
+      # recorded it: downcased, cut at "::" ("OpenAI::Chat" → "openai"),
+      # and the few other spellings mapped (PROVIDER_SLUGS). nil for none.
+      #
+      # @return [String, nil]
+      def provider_slug(provider)
+        slug = provider.to_s.strip.downcase.split("::").first.to_s
+        return nil if slug.empty?
+
+        PROVIDER_SLUGS.fetch(slug, slug)
+      end
+
+      # Whether +model+ is an Ollama model: run under Ollama (either
+      # provider name), or spelled with a local server's cloud marker.
+      def ollama?(model, provider = nil)
+        OLLAMA_PROVIDERS.include?(provider_slug(provider)) || ollama_cloud_model?(model)
+      end
+
+      # Whether +model+ carries a local Ollama server's cloud marker.
+      def ollama_cloud_model?(model)
+        name = model.to_s.strip
+        OLLAMA_CLOUD_MARKERS.any? { |marker| name.end_with?(marker) }
+      end
+
+      # The name Ollama Cloud lists a model under: "gpt-oss:120b-cloud" →
+      # "gpt-oss:120b", "glm-4.6:cloud" → "glm-4.6"; any other name as given.
+      def ollama_canonical(model)
+        name = model.to_s.strip
+        OLLAMA_CLOUD_MARKERS.each { |marker| return name.delete_suffix(marker) if name.end_with?(marker) }
+        name
+      end
+
       private
 
-      # The registry's rate for the first spelling it knows: the name as
-      # given under the provider it ran on, then bare, then with a gateway
-      # or vendor prefix stripped (under the vendor's own provider), each
-      # with its dots and dashes swapped and its date suffix dropped.
+      # The registry's rate for the first spelling it knows: an Ollama
+      # model under the cloud's listing by the name the cloud uses, then
+      # the name as given under the provider it ran on, then bare, then
+      # with a gateway or vendor prefix stripped (under the vendor's own
+      # provider), each with its dots and dashes swapped and its date
+      # suffix dropped.
       def registry_rate(model, provider)
         return nil unless registry_available?
 
@@ -207,9 +300,15 @@ module ActionAgent
       # [[id, provider], ...] to try in order, without repeats.
       def lookup_candidates(model, provider)
         name = model.strip
-        provider = provider&.downcase
         candidates = []
 
+        if ollama?(name, provider)
+          ollama_names(name).each do |candidate|
+            candidates << [ candidate, OLLAMA_CLOUD_PROVIDER ]
+            candidates << [ candidate, "ollama" ]
+          end
+        end
+
         head, rest = name.split("/", 2)
         if rest.present? && GATEWAY_PREFIXES.include?(head.downcase)
           provider ||= head.downcase
@@ -243,9 +342,21 @@ module ActionAgent
         end.uniq
       end
 
-      # An exact row for the normalised name, else the first pattern the
-      # name as given matches, else the default.
-      def static_rate(model)
+      # The names Ollama Cloud's listing may hold an Ollama model under: the
+      # name the cloud uses, then without a `:latest` tag.
+      def ollama_names(model)
+        canonical = ollama_canonical(model)
+        [ canonical, canonical.delete_suffix(":latest") ].uniq
+      end
+
+      # Ollama Cloud's own row for an Ollama model, else an exact row for
+      # the normalised name, else the first pattern the name as given
+      # matches, else the default.
+      def static_rate(model, provider = nil)
+        if ollama?(model, provider) && (row = ollama_names(model).filter_map { |name| OLLAMA_CLOUD_RATES[name] }.first)
+          return { input: row[0], output: row[1], source: "catalog" }
+        end
+
         if (exact = STATIC_RATES[normalize(model)])
           return { input: exact[0], output: exact[1], source: "pattern" }
         end

data/app/models/action_agent/telemetry_trace.rb

@@ -85,26 +85,47 @@ module ActionAgent
     # in Ruby, which costs more but keeps the dashboard adapter-agnostic.
     def self.pluck_with_llm_model(scope, *columns)
       if postgres?
-        scope.pluck(
-          Arel.sql(
-            # spans is cast rather than assumed to be jsonb: the column is
-            # json on every install created before the migration template
-            # started picking jsonb per adapter, and jsonb_array_elements
-            # rejects a json argument outright.
-            "(SELECT s.value -> 'attributes' ->> 'llm.model' " \
-            "FROM jsonb_array_elements(spans::jsonb) AS s " \
-            "WHERE s.value ->> 'type' = 'llm' LIMIT 1)"
-          ),
-          *columns
-        )
+        scope.pluck(llm_span_attribute_sql("llm.model"), *columns)
       else
         scope.pluck(:spans, *columns).map do |spans, *rest|
-          llm = Array(spans).find { |span| span.is_a?(Hash) && span["type"].to_s == "llm" }
-          [ llm&.dig("attributes", "llm.model"), *rest ]
+          [ first_llm_span(spans)&.dig("attributes", "llm.model"), *rest ]
         end
       end
     end
 
+    # Plucks [llm_model, llm_provider, *columns] per trace: as
+    # pluck_with_llm_model, with the provider the first llm span recorded
+    # beside its model, for a caller that prices the tokens (ModelPricing
+    # looks a model up under the provider that served it).
+    def self.pluck_with_llm_model_and_provider(scope, *columns)
+      if postgres?
+        scope.pluck(llm_span_attribute_sql("llm.model"), llm_span_attribute_sql("llm.provider"), *columns)
+      else
+        scope.pluck(:spans, *columns).map do |spans, *rest|
+          llm = first_llm_span(spans)
+          [ llm&.dig("attributes", "llm.model"), llm&.dig("attributes", "llm.provider"), *rest ]
+        end
+      end
+    end
+
+    # The first llm span's +attribute+, read in SQL. spans is cast rather
+    # than assumed to be jsonb: the column is json on every install created
+    # before the migration template started picking jsonb per adapter, and
+    # jsonb_array_elements rejects a json argument outright.
+    def self.llm_span_attribute_sql(attribute)
+      Arel.sql(
+        "(SELECT s.value -> 'attributes' ->> '#{attribute}' " \
+        "FROM jsonb_array_elements(spans::jsonb) AS s " \
+        "WHERE s.value ->> 'type' = 'llm' LIMIT 1)"
+      )
+    end
+    private_class_method :llm_span_attribute_sql
+
+    def self.first_llm_span(spans)
+      Array(spans).find { |span| span.is_a?(Hash) && span["type"].to_s == "llm" }
+    end
+    private_class_method :first_llm_span
+
     # The trace columns the Metrics report reads, in the order
     # pluck_metrics_rows returns them (before the span-derived fields).
     METRICS_COLUMNS = %i[

data/app/queries/action_agent/agent_executions.rb

@@ -136,6 +136,7 @@ module ActionAgent
 
       scope.map do |run|
         model = run.output_metadata&.dig("model")
+        provider = run.output_metadata&.dig("provider")
         Row.new(
           id: run.id,
           source: "dashboard",
@@ -147,13 +148,14 @@ module ActionAgent
           output_tokens: run.output_tokens.to_i,
           cost: ModelPricing.estimate(
             model: model,
+            provider: provider,
             input_tokens: run.input_tokens,
             output_tokens: run.output_tokens
           ),
           trace_id: run.trace_id,
           agent_id: run.agent_id,
           action_name: run.action_name,
-          provider: run.output_metadata&.dig("provider"),
+          provider: provider,
           model: model,
           input_preview: run.input_prompt.to_s.truncate(160),
           output_preview: run.output.to_s.truncate(160).presence,
@@ -183,6 +185,7 @@ module ActionAgent
           output_tokens: trace.total_output_tokens.to_i,
           cost: ModelPricing.estimate(
             model: model,
+            provider: trace.provider,
             input_tokens: trace.total_input_tokens,
             output_tokens: trace.total_output_tokens
           ),

data/app/queries/action_agent/metrics_report.rb

@@ -407,7 +407,7 @@ module ActionAgent
     end
 
     def cost_for(row)
-      ModelPricing.estimate(model: row.model, input_tokens: row.input_tokens, output_tokens: row.output_tokens) || 0.0
+      ModelPricing.estimate(model: row.model, provider: row.provider, input_tokens: row.input_tokens, output_tokens: row.output_tokens) || 0.0
     end
 
     def percent_change(before, after)

data/app/serializers/action_agent/telemetry_trace_serializer.rb

@@ -55,6 +55,7 @@ module ActionAgent
         },
         estimated_cost: ModelPricing.estimate(
           model: @trace.model,
+          provider: @trace.provider,
           input_tokens: @trace.total_input_tokens,
           output_tokens: @trace.total_output_tokens
         )

data/app/services/action_agent/agent_execution_service.rb

@@ -695,14 +695,16 @@ module ActionAgent
     end
 
     # The credentials the run's owner holds, scrubbed from the browser
-    # actions the run records: provider keys, the GitHub token, and the
-    # runtime and browser tokens of the sandbox the run reaches.
+    # actions the run records: provider keys, the GitHub token, the header
+    # values of the owner's own MCP servers, and the runtime and browser
+    # tokens of the sandbox the run reaches.
     def recording_secrets
       sandbox_id = @run.try(:sandbox_id)
       sandbox = sandbox_id && SandboxSession.for_owner(owner).find_by(session_id: sandbox_id)
       [
         *ProviderKey.for_owner(owner).limit(RECORDING_SECRET_LOOKUP_LIMIT).pluck(:credential, :api_key).flatten,
         *GithubConnection.for_owner(owner).limit(RECORDING_SECRET_LOOKUP_LIMIT).pluck(:access_token),
+        *MCPServerConfig.for_owner(owner).limit(RECORDING_SECRET_LOOKUP_LIMIT).flat_map(&:secret_values),
         sandbox&.runtime_mcp_token,
         sandbox&.browser_token,
         *owner_provider_options(requested_provider).values_at(:access_token, :api_key)