Module: Legion::LLM::Call::Providers

Extended by:
Legion::Logging::Helper
Defined in:
lib/legion/llm/call/providers.rb

Class Method Summary collapse

Class Method Details

.adapter_instance_config(config, instance_id) ⇒ Object 



88
89
90
91
92
 
# File 'lib/legion/llm/call/providers.rb', line 88

def adapter_instance_config(config, instance_id)
  config.except(:tier).tap do |registry_config|
    registry_config[:instance_id] ||= instance_id
  end
end

.instance_metadata(config) ⇒ Object 



94
95
96
97
98
99
100
 
# File 'lib/legion/llm/call/providers.rb', line 94

def instance_metadata(config)
  meta = { tier: config[:tier], capabilities: config[:capabilities] || [] }
  meta[:default_model] = config[:default_model] if config[:default_model]
  meta[:source] = config[:source] if config[:source]
  meta[:credential_fingerprint] = config[:credential_fingerprint] if config[:credential_fingerprint]
  meta
end

.loaded_provider_modules ⇒ Object 



31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/legion/llm/call/providers.rb', line 31

def loaded_provider_modules
  return [] unless defined?(Legion::Extensions::Llm)

  Legion::Extensions::Llm.constants(false).filter_map do |const_name|
    mod = Legion::Extensions::Llm.const_get(const_name, false)
    provider_module?(mod) ? mod : nil
  rescue NameError => e
    log.debug "[llm][providers] action=discover_provider_modules const=#{const_name} error=#{e.class} — #{e.message}"
    nil
  end
end

.log_available ⇒ Object 



111
112
113
114
115
116
117
118
119
 
# File 'lib/legion/llm/call/providers.rb', line 111

def log_available
  instances = Call::Registry.all_instances
  if instances.any?
    summary = instances.map { |i| "#{i[:provider]}/#{i[:instance]}" }.join(', ')
    log.info "[llm][providers] available instances=#{summary}"
  else
    log.error '[llm][providers] no providers available — no instances registered'
  end
end

.normalize_instance_config(config) ⇒ Object 



84
85
86
 
# File 'lib/legion/llm/call/providers.rb', line 84

def normalize_instance_config(config)
  config.to_h.transform_keys { |key| key.respond_to?(:to_sym) ? key.to_sym : key }
end

.provider_aliases(provider_module) ⇒ Object 



78
79
80
81
82
 
# File 'lib/legion/llm/call/providers.rb', line 78

def provider_aliases(provider_module)
  return [] unless provider_module.respond_to?(:provider_aliases)

  Array(provider_module.provider_aliases).compact.map(&:to_sym)
end

.provider_module?(mod) ⇒ Boolean

Returns:

  • (Boolean) 


43
44
45
46
47
48
 
# File 'lib/legion/llm/call/providers.rb', line 43

def provider_module?(mod)
  mod.is_a?(Module) &&
    mod.const_defined?(:PROVIDER_FAMILY, false) &&
    mod.respond_to?(:provider_class) &&
    mod.respond_to?(:discover_instances)
end

.rediscover_all_providers ⇒ Object

– private helpers ————————————————–



25
26
27
28
29
 
# File 'lib/legion/llm/call/providers.rb', line 25

def rediscover_all_providers
  loaded_provider_modules.each { |provider_module| rediscover_provider_module(provider_module) }
rescue StandardError => e
  handle_exception(e, level: :warn, operation: 'llm.providers.rediscover_all')
end

.rediscover_provider_module(provider_module) ⇒ Object 



50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/legion/llm/call/providers.rb', line 50

def rediscover_provider_module(provider_module)
  family = provider_module::PROVIDER_FAMILY.to_sym
  aliases = provider_aliases(provider_module)
  ([family] + aliases).each { |provider| Call::Registry.deregister_provider(provider) }

  provider_module.discover_instances.each do |instance_id, config|
    register_provider_instance(provider_module, family, aliases, instance_id, config)
  end
rescue StandardError => e
  handle_exception(e, level: :warn, handled: true,
                      operation: 'llm.providers.rediscover_provider',
                      provider: safe_provider_family(provider_module))
end

.register_provider_instance(provider_module, family, aliases, instance_id, config) ⇒ Object 



64
65
66
67
68
69
70
71
72
73
74
75
76
 
# File 'lib/legion/llm/call/providers.rb', line 64

def register_provider_instance(provider_module, family, aliases, instance_id, config)
  normalized_config = normalize_instance_config(config)
  return if normalized_config[:enabled] == false

  registry_config = adapter_instance_config(normalized_config, instance_id)
  metadata = instance_metadata(normalized_config)
  adapter = Call::LexLLMAdapter.new(family, provider_module.provider_class, instance_config: registry_config)

  Call::Registry.register(family, adapter, instance: instance_id, metadata: metadata)
  aliases.each do |provider_alias|
    Call::Registry.register(provider_alias, adapter, instance: instance_id, metadata: metadata)
  end
end

.safe_provider_family(provider_module) ⇒ Object 



102
103
104
105
106
107
108
109
 
# File 'lib/legion/llm/call/providers.rb', line 102

def safe_provider_family(provider_module)
  return nil unless provider_module&.const_defined?(:PROVIDER_FAMILY, false)

  provider_module::PROVIDER_FAMILY
rescue StandardError => e
  log.debug "[llm][providers] action=safe_provider_family error=#{e.class} — #{e.message}"
  nil
end

.setup ⇒ Object 



13
14
15
16
17
18
19
20
21
 
# File 'lib/legion/llm/call/providers.rb', line 13

def setup
  log.debug '[llm][providers] setup.enter'
  rediscover_all_providers
  log_available
  log.debug '[llm][providers] setup.exit'
rescue StandardError => e
  handle_exception(e, level: :error, operation: 'llm.providers.setup')
  raise
end