Module: Legion::MCP::DeferredRegistry

Extended by:
Logging::Helper
Defined in:
lib/legion/mcp/deferred_registry.rb

Constant Summary collapse

ALWAYS_LOADED =

Tools that are ALWAYS fully loaded (never deferred). These are high-frequency entry points or meta-tools.

%w[
  legion.do
  legion.tools
  legion.run_task
  legion.list_tasks
  legion.get_task
  legion.get_status
  legion.describe_runner
  legion.plan_action
  legion.query_knowledge
  legion.knowledge_context
  legion.knowledge_health
  legion.absorb
  legion.get_task_logs
].freeze

Class Method Summary collapse

Class Method Details

.always_loaded_tools ⇒ Object 



37
38
39
40
41
42
43
44
45
46
47
 
# File 'lib/legion/mcp/deferred_registry.rb', line 37

def always_loaded_tools
  return @always_loaded_cache if @always_loaded_cache

  base = ALWAYS_LOADED.dup
  if Legion::Settings::Extensions.respond_to?(:filter_tools)
    always_entries = Legion::Settings::Extensions.filter_tools(deferred: false)
    base |= always_entries.map { |e| Legion::MCP::ToolAdapter.sanitize_tool_name(e[:name]) } if always_entries.is_a?(Array)
  end
  custom = Legion::Settings.dig(:mcp, :deferred_loading, :always_loaded)
  @always_loaded_cache = custom.is_a?(Array) ? (base | custom) : base
end

.build_tools_list(tool_classes) ⇒ Object 



64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/legion/mcp/deferred_registry.rb', line 64

def build_tools_list(tool_classes)
  deferred_count = 0
  result = tool_classes.map do |tc|
    if deferred?(tc)
      deferred_count += 1
      deferred_entry(tc)
    else
      full_entry(tc)
    end
  end
  log.debug("[mcp][deferred] action=build_tools_list total=#{result.size} " \
            "deferred=#{deferred_count} full=#{result.size - deferred_count}")
  result
end

.deferred?(tool_class) ⇒ Boolean

Returns:

  • (Boolean) 


49
50
51
52
53
54
 
# File 'lib/legion/mcp/deferred_registry.rb', line 49

def deferred?(tool_class)
  return false unless enabled?

  name = tool_class.respond_to?(:tool_name) ? tool_class.tool_name : tool_class.name
  !always_loaded_tools.include?(name)
end

.deferred_entry(tool_class) ⇒ Object 



56
57
58
 
# File 'lib/legion/mcp/deferred_registry.rb', line 56

def deferred_entry(tool_class)
  { name: tool_class.tool_name, description: tool_class.description }
end

.enabled? ⇒ Boolean

Returns:

  • (Boolean) 


32
33
34
35
 
# File 'lib/legion/mcp/deferred_registry.rb', line 32

def enabled?
  setting = Legion::Settings.dig(:mcp, :deferred_loading, :enabled)
  setting.nil? || setting
end

.full_entry(tool_class) ⇒ Object 



60
61
62
 
# File 'lib/legion/mcp/deferred_registry.rb', line 60

def full_entry(tool_class)
  tool_class.to_h
end

.reset_cache! ⇒ Object 



28
29
30
 
# File 'lib/legion/mcp/deferred_registry.rb', line 28

def reset_cache!
  @always_loaded_cache = nil
end

.resolve_schemas(tool_names, tool_classes) ⇒ Object 



79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/legion/mcp/deferred_registry.rb', line 79

def resolve_schemas(tool_names, tool_classes)
  log.debug("[mcp][deferred] action=resolve_schemas requested=#{tool_names.size}")
  result = tool_names.filter_map do |name|
    tc = tool_classes.find { |klass| klass.tool_name == name }
    next unless tc

    tc.to_h
  end
  log.debug("[mcp][deferred] action=resolve_schemas.complete resolved=#{result.size}")
  result
end