actionagent 1.5.2 → 1.6.0

data/app/services/action_agent/agent_tool_roster.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+module ActionAgent
+  # One agent's tool roster, as the agent editor's Tools tab reads it: every
+  # tool the agent can be offered and every MCP service it can be given, each
+  # carrying what the window actually recorded for it.
+  #
+  # Three groups, one row vocabulary — the same one the Tools and MCP
+  # Services pages use, so a roster reads the way the observability views do:
+  #
+  # * **Agent-defined** — tools discovered from the rosters this agent's own
+  #   generations offered (ToolDiscovery's +agent+ origin). Schema-derived:
+  #   the agent class declares them, so they are reported here rather than
+  #   selected. Read-only for the same reason MCP rows are — a checkbox that
+  #   cannot add or remove the tool is a control that changes nothing.
+  # * **Dashboard** — Agent::AVAILABLE_TOOLS, the capabilities the builder
+  #   offers every agent. These are the roster: +agent.tools+ is what
+  #   AgentToolbox turns into function schemas at generation time.
+  # * **MCP** — never stored on the roster. Computed from the services the
+  #   agent enables, which is where they are edited.
+  #
+  # Enablement reads the agent's own configuration: +tools+ for the dashboard
+  # capabilities, +mcp_servers+ for services and their per-server allow-lists
+  # (an entry with no +tools+ key offers everything the server serves).
+  class AgentToolRoster
+    AGENT_DEFINED = "agent_defined"
+    DASHBOARD = "dashboard"
+    MCP = "mcp"
+
+    # Ordering for the services list: what this agent uses, then what the
+    # workspace already talks to, then the rest of the catalog.
+    STATUS_RANK = { "active" => 0, "configured" => 1, "available" => 2, "idle" => 3 }.freeze
+
+    attr_reader :agent, :discovery
+
+    # @param agent [ActionAgent::Agent] the agent being edited
+    # @param traces [ActiveRecord::Relation] the traces the caller may read
+    # @param hours [Integer] the window the usage columns are scoped to
+    def initialize(agent:, traces:, hours: ToolDiscovery::DEFAULT_WINDOW_HOURS)
+      @agent = agent
+      @discovery = ToolDiscovery.new(
+        traces: traces.for_agent(agent.telemetry_agent_class),
+        agents: Agent.where(id: agent.id),
+        hours: hours
+      )
+    end
+
+    def as_json(*)
+      {
+        window_hours: discovery.window_hours,
+        # Whether any record source had rows in this window. False means the
+        # usage columns have nothing behind them, and the view renders them
+        # as "—" rather than as a row of honest-looking zeroes.
+        usage_available: inventory[:sources].values.any?,
+        services: services,
+        tools: tools
+      }
+    end
+
+    private
+
+    def inventory
+      @inventory ||= discovery.inventory
+    end
+
+    def detected
+      inventory[:tools]
+    end
+
+    def saved_tools
+      @saved_tools ||= Array(agent.tools).map(&:to_s)
+    end
+
+    # --- services ------------------------------------------------------
+
+    def services
+      rows = service_keys.map { |key| service_row(key) }
+      rows.sort_by do |row|
+        [ row[:enabled] ? 0 : 1, STATUS_RANK.fetch(row[:status], 9), -row[:calls], row[:name].to_s.downcase ]
+      end
+    end
+
+    # The catalog, plus anything this agent's traffic or configuration names
+    # that the catalog doesn't describe.
+    def service_keys
+      (MCPCatalog.keys + detected_by_server.keys + configured_servers.keys).uniq
+    end
+
+    def detected_by_server
+      @detected_by_server ||= detected.reject { |tool| tool[:mcp_server].blank? }.group_by { |tool| tool[:mcp_server] }
+    end
+
+    def service_row(key)
+      catalog = MCPCatalog.find(key)
+      used = detected_by_server[key] || []
+      calls = used.sum { |tool| tool[:calls] }
+      enabled = configured_servers.key?(key)
+
+      {
+        key: key,
+        name: catalog ? catalog[:name] : key,
+        description: catalog&.dig(:description),
+        docs_url: catalog&.dig(:docs_url),
+        first_party: catalog ? catalog[:first_party] : false,
+        known: !catalog.nil?,
+        transport: transport_label(catalog),
+        status: service_status(calls, enabled, catalog),
+        enabled: enabled,
+        calls: calls,
+        errors: used.sum { |tool| tool[:errors] },
+        last_seen: used.filter_map { |tool| tool[:last_seen] }.max,
+        tools: service_tools(key, catalog, used)
+      }
+    end
+
+    # How to reach the server, in the one line the expanded panel shows:
+    # "Streamable HTTP · <url>" for the ones the dashboard can call,
+    # "sandbox · <command>" for the ones it can start, "stdio · <command>"
+    # for the rest.
+    def transport_label(catalog)
+      return nil if catalog.nil?
+
+      transport = catalog[:transport].to_s
+      return [ "Streamable HTTP", catalog[:url] ].compact.join(" · ") if transport == "http"
+
+      prefix = catalog[:sandbox] ? "sandbox" : transport.presence
+      [ prefix, catalog[:command] ].compact.join(" · ").presence
+    end
+
+    def service_status(calls, enabled, catalog)
+      return "active" if calls.positive?
+      return "configured" if enabled
+      return "available" if catalog
+
+      "idle"
+    end
+
+    # What the service offers: the catalog's tool hints unioned with the
+    # tools this agent was actually seen calling on it, so a server whose
+    # roster has drifted from the catalog still lists what it really serves.
+    def service_tools(key, catalog, used)
+      by_name = used.index_by { |tool| tool[:base_name] }
+      allowed = allowed_tools(key)
+      names = (Array(catalog&.dig(:tools)) + by_name.keys).uniq
+
+      names.map do |name|
+        usage_row(by_name[name]).merge(
+          name: name,
+          description: by_name[name]&.dig(:description),
+          enabled: allowed.nil? || allowed.include?(name)
+        )
+      end
+    end
+
+    # --- tools ---------------------------------------------------------
+
+    def tools
+      agent_defined_rows + dashboard_rows
+    end
+
+    # Schema-derived tools: whatever this agent's generations offered that
+    # is neither an MCP tool nor one of the dashboard's own.
+    def agent_defined_rows
+      detected
+        .select { |tool| tool[:origin] == ToolDiscovery::ORIGIN_AGENT }
+        .reject { |tool| dashboard_function_names.include?(tool[:name]) }
+        .map do |tool|
+          usage_row(tool).merge(
+            key: tool[:name],
+            name: tool[:name],
+            source: AGENT_DEFINED,
+            description: tool[:description],
+            # The agent class declares these; the dashboard reports them.
+            enabled: true,
+            editable: false
+          )
+        end
+    end
+
+    def dashboard_rows
+      Agent::AVAILABLE_TOOLS.map do |capability|
+        usage_row(capability_usage(capability)).merge(
+          key: capability,
+          name: capability,
+          source: DASHBOARD,
+          description: Agent::TOOL_DESCRIPTIONS[capability],
+          enabled: saved_tools.include?(capability),
+          editable: true
+        )
+      end
+    end
+
+    # A capability is one checkbox over the several functions it exposes
+    # ("memory" is save_memory + recall_memory), so its usage is their sum.
+    def capability_usage(capability)
+      names = (AgentToolbox::DEFINITIONS[capability]&.map { |definition| definition[:name].to_s } || []) + [ capability ]
+      rows = detected.select { |tool| names.include?(tool[:name]) }
+      return nil if rows.empty?
+
+      timed = rows.filter_map { |row| [ row[:avg_duration_ms], row[:calls] ] if row[:avg_duration_ms] }
+      weighted = timed.sum { |average, calls| average * [ calls, 1 ].max }
+      samples = timed.sum { |_average, calls| [ calls, 1 ].max }
+
+      {
+        calls: rows.sum { |row| row[:calls] },
+        errors: rows.sum { |row| row[:errors] },
+        avg_duration_ms: samples.positive? ? (weighted / samples).round : nil,
+        last_seen: rows.filter_map { |row| row[:last_seen] }.max
+      }
+    end
+
+    def usage_row(tool)
+      {
+        calls: tool ? tool[:calls] : 0,
+        errors: tool ? tool[:errors] : 0,
+        avg_duration_ms: tool ? tool[:avg_duration_ms] : nil,
+        last_seen: tool ? tool[:last_seen] : nil
+      }
+    end
+
+    # Every function name the dashboard's own toolbox implements, so a
+    # builtin never lands in the agent-defined group under its bare name.
+    def dashboard_function_names
+      @dashboard_function_names ||= ToolDiscovery.builtin_tools | Agent::AVAILABLE_TOOLS.to_set
+    end
+
+    # --- the agent's MCP configuration ---------------------------------
+
+    # server key => the entry the agent stores for it. Entries are bare
+    # strings or builder hashes, and an agent seeded from an older template
+    # carries a top-level Hash keyed by server name — the same three shapes
+    # EvaluationToolResolver tolerates.
+    def configured_servers
+      @configured_servers ||= configured_entries.each_with_object({}) do |entry, map|
+        key = entry_key(entry)
+        map[key] = entry if key.present?
+      end
+    end
+
+    def configured_entries
+      servers = agent.mcp_servers
+
+      if servers.is_a?(Hash)
+        servers.map { |key, value| value.respond_to?(:key?) ? value.to_h.stringify_keys.merge("key" => key.to_s) : key.to_s }
+      else
+        Array(servers)
+      end
+    end
+
+    def entry_key(entry)
+      return entry.to_s.strip.presence if entry.is_a?(String) || entry.is_a?(Symbol)
+      return nil unless entry.respond_to?(:key?)
+
+      (entry["key"] || entry[:key] || entry["name"] || entry[:name]).to_s.strip.presence
+    end
+
+    # The per-server allow-list, or nil when the entry names none — which
+    # means the agent is offered every tool the server serves.
+    def allowed_tools(key)
+      entry = configured_servers[key]
+      return nil unless entry.respond_to?(:key?)
+
+      names = entry["tools"] || entry[:tools]
+      return nil if names.nil?
+
+      Array(names).filter_map { |tool| (tool.respond_to?(:key?) ? tool["name"] || tool[:name] : tool).to_s.presence }
+    end
+  end
+end

data/app/services/action_agent/agent_toolbox.rb

@@ -231,13 +231,22 @@ module ActionAgent
       def call(name, **kwargs)
         return { error: "Unknown tool: #{name}" } unless function?(name)
 
-        schema_tool = ActionAgent.schema_tool_class_for(name.to_s)
-        if schema_tool
+        # Who the call is for is never one of the call's arguments: it comes
+        # off here, before a tool sees them. That keeps a built-in from
+        # meeting an unexpected keyword, and keeps the cache key below over
+        # the arguments alone.
+        actor = kwargs.delete(:actor)
+
+        if (schema_tool = ActionAgent.schema_tool_class_for(name.to_s))
           # `actor:` is the host's authorization seam — the scope block runs
           # inside the call. It is passed through untouched, including nil,
           # so a host scope decides what an unattributed run may read rather
           # than the engine widening it.
-          return schema_tool.call(name.to_s, actor: kwargs.delete(:actor), **kwargs)
+          #
+          # Deliberately not cached: a scoped read is one caller's answer,
+          # and replaying it for the next caller would hand them rows their
+          # own scope would have refused.
+          return schema_tool.call(name.to_s, actor: actor, **kwargs)
         end
 
         return public_send(FUNCTIONS.fetch(name.to_s), **kwargs) if UNCACHED_FUNCTIONS.include?(name.to_s)

data/app/services/action_agent/scenario_evaluation_runner.rb

@@ -147,7 +147,8 @@ module ActionAgent
       agent_run = @evaluation.agent.test_execute(
         scenario.prompt,
         model_override: spec.model,
-        provider_override: spec.provider
+        provider_override: spec.provider,
+        actor: replay_actor
       )
 
       Evals::Replay.new(
@@ -162,6 +163,21 @@ module ActionAgent
       )
     end
 
+    # The caller a replay runs on behalf of: the evaluation's owner, when the
+    # install owns agents per user. A run with no caller reads, through any
+    # host scope, as "no access" — every tool answers empty and the suite
+    # grades an agent that never saw a row — so the person the evaluation
+    # belongs to is the right default, as the key's owner is over MCP. An
+    # account is who is billed, not who is allowed (see Api::BaseController
+    # #agent_actor), so a multi-tenant install replays unattributed unless a
+    # host adapter (ActionAgent.scenario_evaluation_adapter_resolver) runs
+    # the suite itself.
+    def replay_actor
+      return nil if ActionAgent.multi_tenant? || ActionAgent.user_class.blank?
+
+      owner
+    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

data/config/routes.rb

@@ -38,6 +38,9 @@ ActionAgent::Engine.routes.draw do
         post :duplicate
         get :export
         get :analytics
+        # The Tools tab's roster: offerable tools and MCP services, each
+        # with what the window recorded for it.
+        get :tool_roster
         # The runner's conversation picker: this agent's persisted contexts,
         # and a fresh one to pin a first message to.
         get :conversations

data/lib/action_agent/version.rb

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

data/lib/action_agent.rb

@@ -145,6 +145,26 @@ module ActionAgent
     # @return [Proc, nil]
     attr_accessor :current_user_resolver
 
+    # Resolves the caller an agent run executes on behalf of — what reaches
+    # +ActiveAgent::Base#current_user+, a SchemaTools +scope+ block, and any
+    # authorization gem an agent calls from its callbacks.
+    #
+    # Called with the controller, so the same seam covers a browser session
+    # and an MCP request. Whatever it returns is passed through untouched:
+    # the engine never interprets an actor, and never widens one.
+    #
+    #   config.agent_actor_resolver = ->(controller) { controller.current_user }
+    #
+    # Unset means the dashboard's signed-in user, and, for the MCP endpoint,
+    # the API key's owner — the identity that authenticated the call. A host
+    # whose keys are issued per end user overrides this to return that user.
+    #
+    # Returning nil runs the agent unattributed, which a correctly written
+    # host scope reads as "no access". That is the safe direction, and it is
+    # why this is never defaulted to something more privileged.
+    # @return [Proc, nil]
+    attr_accessor :agent_actor_resolver
+
     # Resolves the current tenant from the controller. See
     # current_user_resolver.
     # @return [Proc, nil]
@@ -348,9 +368,21 @@ module ActionAgent
     # @return [Array<Class, String>, nil]
     attr_accessor :schema_tools
 
+    # Whether the MCP facade (POST <mount>/mcp) offers the host's schema tools
+    # directly — find_<records>, count_<records>, get_<record> — beside the
+    # run_<slug> agent tools. Each call runs as the key's caller, through the
+    # host's own scope, exactly as it would inside an agent run. On by
+    # default: the host declared the tools; set it to false to keep them
+    # reachable only through agents.
+    # @return [Boolean]
+    attr_accessor :mcp_schema_tools
+
     # Directory scanned for SchemaTools subclasses when {#schema_tools} is
     # unset. Relative to the host's root. Set to nil to disable discovery and
-    # require an explicit declaration.
+    # require an explicit declaration. Classes built at runtime with
+    # +ActiveAgent::SchemaTools.define+ are discovered alongside the files
+    # whatever this is set to; only an explicit {#schema_tools} list excludes
+    # them.
     # @return [String, nil]
     attr_accessor :schema_tools_path
 
@@ -368,6 +400,13 @@ module ActionAgent
       @multi_tenant == true
     end
 
+    # Whether the MCP facade serves the host's schema tools directly.
+    #
+    # @return [Boolean]
+    def mcp_schema_tools?
+      @mcp_schema_tools != false
+    end
+
     # Returns whether agent execution is permitted.
     #
     # @return [Boolean]
@@ -519,8 +558,10 @@ module ActionAgent
       @sign_out_path = nil
       @sign_in_path = nil
       @mcp_catalog = []
+      @agent_actor_resolver = nil
       @schema_tools = nil
       @schema_tools_path = "app/agent_tools"
+      @mcp_schema_tools = nil
     end
 
     # Host-declared schema tool classes, resolved from names and filtered to
@@ -550,14 +591,31 @@ module ActionAgent
       schema_tool_classes.flat_map(&:tool_names).map(&:to_s)
     end
 
-    # SchemaTools subclasses defined under {#schema_tools_path}.
+    # SchemaTools classes on offer when {#schema_tools} is unset: the files
+    # under {#schema_tools_path}, and every runtime definition in
+    # +ActiveAgent::SchemaTools.registry+.
     #
     # The files are loaded before reading +descendants+: in development nothing
     # has referenced those constants yet, so the list would otherwise be empty
     # at boot and fill in only once something happened to touch them.
+    # Runtime-built classes are read from the registry, never from
+    # +descendants+, where every class ever built stays until collected and a
+    # superseded definition would be offered beside its replacement. A runtime
+    # definition for a model also supersedes a file for that model: it is the
+    # more recent intent.
     # @return [Array<Class>]
     def discovered_schema_tools
-      return [] if @schema_tools_path.blank? || !defined?(ActiveAgent::SchemaTools)
+      return [] unless defined?(ActiveAgent::SchemaTools)
+
+      from_registry = ActiveAgent::SchemaTools.respond_to?(:registry) ? ActiveAgent::SchemaTools.registry.values : []
+      (from_registry + file_defined_schema_tools).uniq { |klass| klass.model.name }
+    end
+
+    # The named SchemaTools subclasses under {#schema_tools_path}; none when
+    # the path is unset or the directory does not exist.
+    # @return [Array<Class>]
+    def file_defined_schema_tools
+      return [] if @schema_tools_path.blank?
       return [] unless defined?(Rails) && Rails.respond_to?(:root) && Rails.root
 
       root = Rails.root.join(@schema_tools_path)
@@ -569,7 +627,11 @@ module ActionAgent
         warn "[ActionAgent] could not load #{path}: #{e.class} - #{e.message}"
       end
 
-      ActiveAgent::SchemaTools.descendants.select { |klass| klass.name.present? }
+      ActiveAgent::SchemaTools.descendants.select { |klass| klass.name.present? && !runtime_schema_tools?(klass) }
+    end
+
+    def runtime_schema_tools?(klass)
+      klass.respond_to?(:runtime?) && klass.runtime?
     end
 
     # The schema tool class that generated +name+, or nil.

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: actionagent
 version: !ruby/object:Gem::Version
-  version: 1.5.2
+  version: 1.6.0
 platform: ruby
 authors:
 - Justin Bowen
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-11 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activeagent
@@ -194,6 +193,7 @@ files:
 - app/services/action_agent/agent_execution_service.rb
 - app/services/action_agent/agent_registrar.rb
 - app/services/action_agent/agent_scorecard.rb
+- app/services/action_agent/agent_tool_roster.rb
 - app/services/action_agent/agent_toolbox.rb
 - app/services/action_agent/dashboard_assistant_service.rb
 - app/services/action_agent/evaluation_evidence.rb
@@ -238,7 +238,6 @@ metadata:
   documentation_uri: https://docs.activeagents.ai/framework/self-hosted-observability
   source_code_uri: https://github.com/activeagents/activeagent
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -253,8 +252,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: The Active Agent dashboard, as a mountable Rails engine
 test_files: []