actionagent 1.5.0 → 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

@@ -203,11 +203,23 @@ module ActionAgent
       # Tool definitions for the subset of an agent's enabled tools that have
       # server-side implementations.
       def definitions_for(tool_names)
-        Array(tool_names).flat_map { |name| DEFINITIONS[name.to_s] || [] }
+        Array(tool_names).flat_map do |name|
+          DEFINITIONS[name.to_s] || schema_tool_definitions(name.to_s)
+        end
       end
 
       def function?(name)
-        FUNCTIONS.key?(name.to_s)
+        FUNCTIONS.key?(name.to_s) || ActionAgent.schema_tool_class_for(name.to_s).present?
+      end
+
+      # Definitions for a host-declared schema tool, or [] when the name is
+      # not one. Each generated tool is its own entry so an agent enables them
+      # individually rather than as a group.
+      def schema_tool_definitions(name)
+        klass = ActionAgent.schema_tool_class_for(name)
+        return [] unless klass
+
+        Array(klass.tool_definitions).select { |definition| definition[:name].to_s == name }
       end
 
       # Executes a tool call. Returns a result hash; errors are returned as
@@ -218,6 +230,25 @@ module ActionAgent
       # instead of re-running the side effect.
       def call(name, **kwargs)
         return { error: "Unknown tool: #{name}" } unless function?(name)
+
+        # 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.
+          #
+          # 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)
 
         cached_fetch(name, kwargs) do

data/app/services/action_agent/mcp_tool_dispatcher.rb

@@ -57,7 +57,15 @@ module ActionAgent
     # contributes nothing rather than failing the run — the tools it serves
     # then simply are not offered, and a scenario expecting them fails with a
     # fault naming them.
+    #
+    # A server that fails discovery also records why, in +discovery_errors+.
+    # Contributing nothing keeps the run alive, but silence is indistinguishable
+    # from a server that legitimately serves no tools — and an agent offered no
+    # tools answers from the model alone, which reads as a confident, fabricated
+    # result rather than a transport failure (#425).
     def tool_definitions
+      @discovery_errors = {}
+
       resolver.declared_server_keys.flat_map do |key|
         entry = MCPCatalog.find(key)
         next [] unless entry && entry[:transport].to_s.in?(HTTP_TRANSPORTS) && entry[:url].present?
@@ -66,11 +74,35 @@ module ActionAgent
           client_for(entry).list_tools
         rescue MCPClient::Error => e
           Rails.logger.warn("[MCPToolDispatcher] #{key} tools/list failed: #{e.message}")
+          @discovery_errors[key] =
+            "Cannot load tools from MCP server '#{key}' (#{entry[:url]}): #{e.message}. " \
+            "Check its URL, transport and credentials."
           []
         end
       end
     end
 
+    # Why each declared server contributed no tools, keyed by server. Empty
+    # until +tool_definitions+ has run, and empty after a run where every
+    # declared server answered.
+    #
+    # @return [Hash{String => String}]
+    def discovery_errors
+      @discovery_errors ||= {}
+    end
+
+    # Whether every server the agent declares failed discovery. The tool-less
+    # execution that follows cannot produce a meaningful result, so a caller
+    # can fail loudly instead of scoring an answer the model invented.
+    def all_servers_failed?
+      keys = resolver.declared_server_keys.select do |key|
+        entry = MCPCatalog.find(key)
+        entry && entry[:transport].to_s.in?(HTTP_TRANSPORTS) && entry[:url].present?
+      end
+
+      keys.any? && keys.all? { |key| discovery_errors.key?(key) }
+    end
+
     private
 
     attr_reader :agent, :resolver

data/app/services/action_agent/scenario_evaluation_runner.rb

@@ -80,6 +80,7 @@ module ActionAgent
         scores: scores_for(report, run),
         samples_evaluated: report.results.size,
         samples_passed: report.results.count(&:passed?),
+        error_message: discovery_warning,
         completed_at: Time.current
       )
       run
@@ -146,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(
@@ -161,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
@@ -240,10 +257,48 @@ module ActionAgent
       end
     end
 
+    # Every tool the agent could actually call, for the diagnosis roster: the
+    # engine's own toolbox plus whatever its MCP servers serve.
+    #
+    # Listing only the toolbox understated the roster, so a diagnosis could
+    # report "none of the available tools covers this task" while naming a list
+    # the agent's MCP tools were missing from.
     def tool_roster
-      @tool_roster ||= AgentToolbox.definitions_for(@evaluation.agent.tools).to_h do |definition|
-        [ definition[:name].to_s, definition[:description].to_s ]
+      @tool_roster ||= begin
+        definitions = mcp_dispatcher.tool_definitions +
+          AgentToolbox.definitions_for(@evaluation.agent.tools)
+
+        definitions.to_h { |definition| [ definition[:name].to_s, definition[:description].to_s ] }
+      end
+    end
+
+    # Discovery failures from the roster above, keyed by server. Reading them
+    # requires tool_definitions to have run, which tool_roster does.
+    def mcp_discovery_errors
+      tool_roster
+      mcp_dispatcher.discovery_errors
+    end
+
+    def mcp_dispatcher
+      @mcp_dispatcher ||= MCPToolDispatcher.new(@evaluation.agent)
+    end
+
+    # A run whose every declared MCP server failed discovery scored an agent
+    # that had no tools to call. The scores are real but meaningless — the
+    # model answered from its own weights — so the run says so rather than
+    # leaving the cause in a log line (#425).
+    def discovery_warning
+      errors = mcp_discovery_errors
+      return nil if errors.empty?
+
+      prefix = if mcp_dispatcher.all_servers_failed?
+        "Every MCP server this agent declares failed tool discovery, so it ran with no MCP tools " \
+        "and any specifics in its answers are unverified."
+      else
+        "Some of this agent's MCP servers failed tool discovery, so part of its toolset was unavailable."
       end
+
+      "#{prefix} #{errors.values.join(' ')}"
     end
 
     # The judge the evaluation's owner has credentials for, wrapped for the

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.0"
+  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]
@@ -330,6 +350,42 @@ module ActionAgent
     # @return [Array<Hash>]
     attr_accessor :mcp_catalog
 
+    # 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
+    # execution, and named in an evaluation's +tools:+ expectation.
+    #
+    #   ActionAgent.configure do |config|
+    #     config.schema_tools = [TicketTools, TaskTools, MilestoneTools]
+    #   end
+    #
+    # Accepts classes or class-name strings; strings are resolved lazily so a
+    # host can declare them from an initializer before autoloading has run.
+    #
+    # Leave it unset and every ActiveAgent::SchemaTools subclass found in
+    # {#schema_tools_path} is offered instead — a host adds a tool by adding a
+    # file, without naming it twice.
+    # @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. 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
+
     # Value stored in polymorphic *_type columns for dashboard agents
     # (agent_memories.memorable_type, agent_contexts.contextable_type).
     # Unset means the class name. A host app whose existing rows were
@@ -344,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]
@@ -495,6 +558,86 @@ 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
+    # those that are usable (declared a model and generated a roster).
+    #
+    # Resolution happens per call rather than at configure time: a host
+    # declares these in an initializer, before its own classes are autoloaded.
+    # @return [Array<Class>]
+    def schema_tool_classes
+      declared = @schema_tools.nil? ? discovered_schema_tools : Array(@schema_tools)
+
+      declared.filter_map do |entry|
+        klass = entry.is_a?(String) ? entry.safe_constantize : entry
+        next unless klass.respond_to?(:tool_definitions) && klass.respond_to?(:model)
+        next if klass.model.blank?
+        # An anonymous class built at runtime is usable but not discoverable —
+        # it would accumulate across reloads with no way to supersede itself.
+        next if entry.is_a?(Class) && klass.name.blank? && @schema_tools.nil?
+
+        klass
+      end
+    end
+
+    # Every tool name generated by the declared schema tool classes.
+    # @return [Array<String>]
+    def schema_tool_names
+      schema_tool_classes.flat_map(&:tool_names).map(&:to_s)
+    end
+
+    # 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 [] 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)
+      return [] unless Dir.exist?(root)
+
+      Dir[root.join("**/*.rb")].sort.each do |path|
+        require_dependency path
+      rescue StandardError, ScriptError => e
+        warn "[ActionAgent] could not load #{path}: #{e.class} - #{e.message}"
+      end
+
+      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.
+    # @return [Class, nil]
+    def schema_tool_class_for(name)
+      schema_tool_classes.find { |klass| klass.tool?(name) }
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: actionagent
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.6.0
 platform: ruby
 authors:
 - Justin Bowen
@@ -193,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
@@ -251,7 +252,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 3.6.9
 specification_version: 4
 summary: The Active Agent dashboard, as a mountable Rails engine
 test_files: []