Module: Legion::LLM::Router

Extended by:
Legion::Logging::Helper
Defined in:
lib/legion/llm/router.rb,
lib/legion/llm/router/rule.rb,
lib/legion/llm/router/resolution.rb,
lib/legion/llm/router/health_tracker.rb,
lib/legion/llm/router/escalation_chain.rb,
lib/legion/llm/router/gateway_interceptor.rb

Defined Under Namespace

Modules: GatewayInterceptor Classes: EscalationChain, HealthTracker, Resolution, Rule

Class Method Summary collapse

Class Method Details

.health_tracker ⇒ Object 



53
54
55
 
# File 'lib/legion/llm/router.rb', line 53

def health_tracker
  @health_tracker ||= build_health_tracker
end

.reset! ⇒ Object 



66
67
68
 
# File 'lib/legion/llm/router.rb', line 66

def reset!
  @health_tracker = nil
end

.resolve(intent: nil, tier: nil, model: nil, provider: nil, exclude: {}) ⇒ Resolution?

Resolve an LLM routing intent to a tier/provider/model decision.

Parameters:

  • intent (Hash, nil) (defaults to: nil) —

    routing intent (capability, privacy, etc.)

  • tier (Symbol, nil) (defaults to: nil) —

    explicit tier override — skips rule matching

  • model (String, nil) (defaults to: nil) —

    explicit model override

  • provider (Symbol, nil) (defaults to: nil) —

    explicit provider override

Returns:



25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/legion/llm/router.rb', line 25

def resolve(intent: nil, tier: nil, model: nil, provider: nil, exclude: {})
  return explicit_resolution(tier, provider, model) if tier

  return nil unless routing_enabled? && intent

  merged = merge_defaults(intent)
  rules = load_rules
  candidates = select_candidates(rules, merged, exclude: exclude)
  best = pick_best(candidates)
  resolution = best&.to_resolution

  if resolution
    log.info("Routed to tier=#{resolution.tier} provider=#{resolution.provider} model=#{resolution.model} via rule='#{resolution.rule}'")
  else
    log.debug('Router: no rules matched, resolution is nil')
  end

  resolution || arbitrage_fallback(intent)
end

.resolve_chain(intent: nil, tier: nil, model: nil, provider: nil, max_escalations: nil, exclude: {}) ⇒ Object 



45
46
47
48
49
50
51
 
# File 'lib/legion/llm/router.rb', line 45

def resolve_chain(intent: nil, tier: nil, model: nil, provider: nil, max_escalations: nil, exclude: {})
  max = max_escalations || escalation_max_attempts
  return chain_from_defaults(model, provider, max) unless routing_enabled? && (intent || tier)
  return EscalationChain.new(resolutions: [explicit_resolution(tier, provider, model)], max_attempts: max) if tier

  chain_from_intent(intent, max, exclude: exclude)
end

.routing_enabled? ⇒ Boolean

Returns:

  • (Boolean) 


57
58
59
60
61
62
63
64
 
# File 'lib/legion/llm/router.rb', line 57

def routing_enabled?
  settings = routing_settings
  return false if settings.nil? || settings.empty?
  return false unless settings[:enabled]

  rules = settings[:rules]
  rules.is_a?(Array) && !rules.empty?
end

.tier_available?(tier) ⇒ Boolean

Check whether a tier can be used right now. :local — always available :fleet — available when Legion::Transport is loaded :cloud — always available

Returns:

  • (Boolean) 


74
75
76
77
78
79
80
 
# File 'lib/legion/llm/router.rb', line 74

def tier_available?(tier)
  sym = tier.to_sym
  return false if sym == :cloud && privacy_mode?
  return Legion.const_defined?('Transport', false) if sym == :fleet

  true
end