legion-llm 0.9.22 → 0.9.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 428a14e141f5cbbb278e05f49fd198ef13f6e789727037c90154a855b76a8b34
-  data.tar.gz: 8dc2aea0cd776675aad1c8ff198b35f0eba573e4a37c6e2bcdc0b6dfbbb7210b
+  metadata.gz: 8c8c98a439d2e96bba437e5e8b4bf8c47c01277a4079bd459c7257e2990278c6
+  data.tar.gz: f9344c761ebf18b4c5ab271ac8cb5858ce46f791588ace438726002d2907c70e
 SHA512:
-  metadata.gz: 3b9f1b9fae5371eefcbfbc89262bfa422e23df0e2e52d56735c5f3af9912b7245883ae4864568b6d8828e2dfdc3ab8c3d9fd4f125f662d6f8ae51602976d9952
-  data.tar.gz: dcdbf11006d26b929779bdb0e2ae8a541225b3a62c820dd027ef6801198a5056eb1d9a93e7cd504846b11b2196c187d7a415e263592864c3eae5ace4153b31ee
+  metadata.gz: 9574535d0eeca84d522858dd323e8d028994b46b3d3f78a37a8094a4f1a692fbdd68bf24e8a061160b5238a2c3e4f73141e29bf70c6423f18e4b4441937f5417
+  data.tar.gz: 69aa8eccf10beb687b637b7442d9eb8a7bae0d42405fc9cfd47f8c8d5c036b7724df6cb55c10d8264f0701f46f8282f0a44d8622d607a6129a09ab4c39ad2e99

data/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Legion LLM Changelog
 
+## [0.9.23] - 2026-05-13
+
+### Added
+- Router: `registry_entry_for_provider` for explicit provider model resolution
+- Router: model denylist (`deny_model`, `model_denied?`, `excluded_by_denial?`) — config errors auto-deny models
+- Executor: config error detection (`CONFIG_ERROR_PATTERNS`) — prevents circuit breaker trips on auth/validation errors
+- Executor: step timing hash on response (`metrics.timing`, `metrics.latency_legionio_ms`)
+- API: `/api/llm/inference` response includes `provider`, `instance`, `tier`, `metrics`
+- API: `/api/llm/providers` surfaces `source` and `credential_fingerprint`
+- Inventory: provider-scoped queries skip unrelated providers
+- Metering: disk-based JSONL spool when transport unavailable (was dropping events)
+- Discovery: `report_discovery_failure` reports connection failures to health tracker
+- Providers: `enabled: false` instances not registered; `default_model` in metadata
+
+### Changed
+- Router: tier-aware model fallback — global default no longer bleeds across providers
+- Inventory: single-source offerings (native_provider preferred over discovery to eliminate duplicates)
+- Inventory: dedup normalizes `"default"` instance name
+- Discovery: concise connection error log (no stacktrace for unreachable providers)
+- Settings: removed `claude` from `native_providers` list
+
+### Fixed
+- Cache spec rewritten to use real `Legion::Cache` instead of fragile stubs
+
 ## [0.9.22] - 2026-05-12
 
 ### Added

data/lib/legion/llm/api/native/helpers.rb

@@ -498,6 +498,26 @@ module Legion
 
                 nil
               end
+
+              define_method(:build_response_metrics) do |pipeline_response|
+                routing = pipeline_response.routing || {}
+                timestamps = pipeline_response.timestamps || {}
+                metrics = {}
+
+                if (latency = routing[:latency_ms])
+                  metrics[:latency_ms] = latency
+                end
+
+                step_timings = timestamps[:step_timings]
+                if step_timings.is_a?(Hash) && step_timings.any?
+                  metrics[:timing] = step_timings
+                  total = step_timings[:total].to_i
+                  external = step_timings[:provider_call].to_i + step_timings[:tool_calls].to_i
+                  metrics[:latency_legionio_ms] = total - external if total.positive?
+                end
+
+                metrics.empty? ? nil : metrics
+              end
             end
 
             log.debug('[llm][api][helpers] shared helpers registered')

data/lib/legion/llm/api/native/inference.rb

@@ -184,11 +184,15 @@ module Legion
                     request_id:      request_id,
                     content:         full_text,
                     model:           (routing[:model] || routing['model']).to_s,
+                    provider:        (routing[:provider] || routing['provider'])&.to_s,
+                    instance:        (routing[:instance] || routing['instance'])&.to_s,
+                    tier:            (routing[:tier] || routing['tier'])&.to_s,
                     input_tokens:    token_value(tokens, :input),
                     output_tokens:   token_value(tokens, :output),
                     tool_calls:      extract_tool_calls(pipeline_response),
-                    conversation_id: pipeline_response.conversation_id
-                  }
+                    conversation_id: pipeline_response.conversation_id,
+                    metrics:         build_response_metrics(pipeline_response)
+                  }.compact
                   done_payload[:thinking] = pipeline_response.thinking if include_thinking && pipeline_response.thinking
                   emit_sse_event(out, 'done', {
                                    **done_payload
@@ -237,11 +241,16 @@ module Legion
                   tool_calls:      tool_calls,
                   stop_reason:     pipeline_response.stop&.dig(:reason)&.to_s,
                   model:           (routing[:model] || routing['model']).to_s,
+                  provider:        (routing[:provider] || routing['provider'])&.to_s,
+                  instance:        (routing[:instance] || routing['instance'])&.to_s,
+                  tier:            (routing[:tier] || routing['tier'])&.to_s,
                   input_tokens:    token_value(tokens, :input),
                   output_tokens:   token_value(tokens, :output),
-                  conversation_id: pipeline_response.conversation_id
+                  conversation_id: pipeline_response.conversation_id,
+                  metrics:         build_response_metrics(pipeline_response)
                 }
                 payload[:thinking] = pipeline_response.thinking if include_thinking && pipeline_response.thinking
+                payload.compact!
                 json_response(payload, status_code: 200)
               end
             rescue Legion::LLM::AuthError => e

data/lib/legion/llm/api/native/providers.rb

@@ -87,7 +87,7 @@ module Legion
             provider_key = entry[:provider].to_sym
             instance_key = entry[:instance].to_sym
 
-            {
+            result = {
               provider:     entry[:provider].to_s,
               instance:     entry[:instance].to_s,
               tier:         entry.dig(:metadata, :tier)&.to_s,
@@ -102,6 +102,9 @@ module Legion
                             end,
               native:       true
             }
+            result[:source] = entry.dig(:metadata, :source) if entry.dig(:metadata, :source)
+            result[:credential_fingerprint] = entry.dig(:metadata, :credential_fingerprint) if entry.dig(:metadata, :credential_fingerprint)
+            result
           end
         end
       end

data/lib/legion/llm/call/providers.rb

@@ -80,6 +80,8 @@ module Legion
 
         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)
@@ -107,7 +109,11 @@ module Legion
         end
 
         def instance_metadata(config)
-          { tier: config[:tier], capabilities: config[:capabilities] || [] }
+          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
 
         def safe_provider_family(provider_module)

data/lib/legion/llm/discovery.rb

@@ -141,8 +141,7 @@ module Legion
                 }
               end
             rescue StandardError => e
-              handle_exception(e, level:     :debug,
-                                  operation: "discovery.offerings.#{entry[:provider]}/#{entry[:instance]}")
+              report_discovery_failure(entry, e)
               []
             end
           end
@@ -165,6 +164,28 @@ module Legion
 
         private
 
+        def report_discovery_failure(entry, error)
+          provider = entry[:provider]
+          instance = entry[:instance]
+          connection_error = error.is_a?(Faraday::ConnectionFailed) ||
+                             error.message.match?(/connection refused|connect.*timeout|no route to host/i)
+
+          if connection_error
+            log.warn("[llm][discovery] provider=#{provider} instance=#{instance} unreachable: #{error.message}")
+          else
+            handle_exception(error, level: :warn, handled: true,
+                                    operation: "discovery.offerings.#{provider}/#{instance}")
+          end
+
+          return unless defined?(Router) && Router.respond_to?(:health_tracker)
+
+          Router.health_tracker.report(
+            provider: provider, instance: instance,
+            signal: :error, value: 1,
+            metadata: { reason: error.class.name, source: :discovery }
+          )
+        end
+
         def normalize_offering(offering)
           data = if offering.is_a?(Hash)
                    offering

data/lib/legion/llm/inference/executor.rb

@@ -11,7 +11,7 @@ require_relative 'route_attempts'
 module Legion
   module LLM
     module Inference
-      class Executor
+      class Executor # rubocop:disable Metrics/ClassLength
         include Legion::Logging::Helper
         include NativeToolLoop
         include RouteAttempts
@@ -59,6 +59,15 @@ module Legion
 
         ASYNC_SAFE_STEPS = %i[post_response knowledge_capture response_return].freeze
 
+        CONFIG_ERROR_PATTERNS = [
+          /ValidationException/,
+          /AccessDeniedException/,
+          /InvalidModel/i,
+          /model.*not found/i,
+          /not authorized/i,
+          /AWS Marketplace/i
+        ].freeze
+
         MAX_NATIVE_TOOL_ROUNDS = 200
         ToolResultEvent = Struct.new(:result, :tool_call_id, :tool_name, :started_at, keyword_init: true)
 
@@ -160,6 +169,7 @@ module Legion
           skipped = 0
           pipeline_start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
           step_timings = []
+          @step_timing_hash = {}
           STEPS.each do |step|
             if Profile.skip?(@profile, step)
               skipped += 1
@@ -170,9 +180,12 @@ module Legion
             execute_step(step) { send(:"step_#{step}") }
             elapsed_ms = ((::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - t0) * 1000).round
             step_timings << "#{step}=#{elapsed_ms}ms"
+            @step_timing_hash[step] = elapsed_ms
             executed += 1
           end
           total_ms = ((::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - pipeline_start) * 1000).round
+          @step_timing_hash[:total] = total_ms
+          @timestamps[:step_timings] = @step_timing_hash
           log.warn("[pipeline][timing] profile=#{@profile} total=#{total_ms}ms executed=#{executed} skipped=#{skipped} #{step_timings.join(' ')}")
           annotate_top_level_span(steps_executed: executed, steps_skipped: skipped)
         end
@@ -547,9 +560,18 @@ module Legion
           duration_ms = ((Time.now - start_time) * 1000).round
           handle_exception(err, level: :warn, handled: handled, operation: operation,
                                provider: resolution.provider, model: resolution.model, duration_ms: duration_ms)
-          Router.health_tracker.report(provider: resolution.provider, offering_id: resolution.offering_id,
-                                       signal: :error, value: 1,
-                                       metadata: { reason: err.class.name, message: err.message })
+          if config_error?(err)
+            Router.health_tracker.deny_model(
+              provider: resolution.provider,
+              model:    resolution.model,
+              instance: resolution.instance,
+              reason:   err.message
+            )
+          else
+            Router.health_tracker.report(provider: resolution.provider, offering_id: resolution.offering_id,
+                                         signal: :error, value: 1,
+                                         metadata: { reason: err.class.name, message: err.message })
+          end
           @escalation_history << escalation_attempt_hash(
             resolution,
             outcome:     outcome,
@@ -928,6 +950,12 @@ module Legion
           handle_exception(e, level: :warn, operation: 'llm.pipeline.emit_error_audit')
         end
 
+        def config_error?(err)
+          name = err.class.name.to_s
+          msg = err.message.to_s
+          CONFIG_ERROR_PATTERNS.any? { |pat| pat.match?(name) || pat.match?(msg) }
+        end
+
         def execute_pre_provider_steps
           log.debug "[llm][executor] action=pre_provider_steps.enter step_count=#{PRE_PROVIDER_STEPS.size}"
           PRE_PROVIDER_STEPS.each do |step|
@@ -1549,7 +1577,12 @@ module Legion
         end
 
         def build_response_routing
-          routing = { provider: @resolved_provider, model: @resolved_model }
+          routing = {
+            provider: @resolved_provider,
+            instance: @resolved_instance,
+            model:    @resolved_model,
+            tier:     @resolved_tier
+          }.compact
           routing[:offering_id] = @resolved_offering_id if @resolved_offering_id
           routing[:offering_metadata] = @resolved_offering_metadata if @resolved_offering_metadata&.any?
 

data/lib/legion/llm/inventory.rb

@@ -39,15 +39,19 @@ module Legion
         def offerings(filters = {})
           log.debug "[llm][inventory] action=offerings.enter filters=#{filters.keys}"
           normalized_filters = normalize_filter_hash(filters)
+          provider_scope = normalized_filters[:provider]&.to_sym
           list = []
           providers_config.each do |provider_family, config|
             next unless enabled_config?(config)
+            next if provider_scope && provider_family.to_sym != provider_scope
 
             list.concat(provider_offerings(provider_family.to_sym, config))
           end
 
-          list.concat(discovery_offerings)
-          list.concat(native_provider_offerings)
+          native = native_provider_offerings(provider: provider_scope)
+          native_providers = native.map { |o| o[:provider_family]&.to_sym }.uniq
+          list.concat(native)
+          list.concat(discovery_offerings(provider: provider_scope, exclude_providers: native_providers))
           list = dedupe_offerings(list)
           result = filter_offerings(list, normalized_filters)
           log.debug "[llm][inventory] action=offerings.complete total=#{result.size}"
@@ -265,7 +269,7 @@ module Legion
           ))
         end
 
-        def discovery_offerings
+        def discovery_offerings(provider: nil, exclude_providers: [])
           return [] unless defined?(Legion::LLM::Discovery)
 
           cached_models = if Legion::LLM::Discovery.respond_to?(:cached_discovered_models)
@@ -276,6 +280,9 @@ module Legion
 
           cached_models.filter_map do |model_entry|
             provider_family = model_entry[:provider]
+            next if provider && provider_family.to_sym != provider
+            next if exclude_providers.include?(provider_family.to_sym)
+
             config = option(providers_config, provider_family, {})
             next unless enabled_config?(config)
 
@@ -295,11 +302,13 @@ module Legion
           []
         end
 
-        def native_provider_offerings
+        def native_provider_offerings(provider: nil)
           return [] unless defined?(Legion::LLM::Call::Registry)
 
           Legion::LLM::Call::Registry.all_instances.flat_map do |entry|
             provider_name = entry[:provider]
+            next [] if provider && provider_name.to_sym != provider
+
             adapter = entry[:adapter]
             next [] unless adapter.respond_to?(:offerings)
 
@@ -347,7 +356,9 @@ module Legion
 
         def dedupe_offerings(list)
           list.each_with_object({}) do |offering, seen|
-            key = [offering[:provider_family], offering[:provider_instance], offering[:model], offering[:type]]
+            instance = offering[:provider_instance]
+            instance = nil if instance.to_s == 'default'
+            key = [offering[:provider_family], instance, offering[:model], offering[:type]]
             current = seen[key]
             seen[key] = offering if current.nil? || source_priority(offering) > source_priority(current)
           end.values

data/lib/legion/llm/metering.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'legion/logging/helper'
+require 'fileutils'
 require_relative 'metering/estimator'
 require_relative 'metering/tracker'
 require_relative 'metering/tokens'
@@ -12,6 +13,10 @@ module Legion
     module Metering
       extend Legion::Logging::Helper
 
+      SPOOL_DIR = File.expand_path('~/.legionio/data/spool/metering')
+      SPOOL_FILE = File.join(SPOOL_DIR, 'events.jsonl').freeze
+      SPOOL_MUTEX = Mutex.new
+
       def self.load_transport
         return unless defined?(Legion::Transport::Message)
 
@@ -30,8 +35,9 @@ module Legion
           log.info("[llm][metering] published provider=#{event[:provider]} model=#{event[:model_id]}")
           :published
         else
-          log.warn("[llm][metering] dropped provider=#{event[:provider]} model=#{event[:model_id]} reason=transport_unavailable")
-          :dropped
+          spool_event(event)
+          log.info("[llm][metering] spooled provider=#{event[:provider]} model=#{event[:model_id]} reason=transport_unavailable")
+          :spooled
         end
       rescue StandardError => e
         handle_exception(e, level: :warn, operation: 'llm.metering.emit')
@@ -46,8 +52,43 @@ module Legion
       end
 
       def flush_spool
-        log.debug('[llm][metering] spool disabled; metering events are transport-only')
-        0
+        return 0 unless File.exist?(spool_file_path)
+
+        event_class = metering_event_class
+        unless event_class && transport_connected?
+          log.debug('[llm][metering] flush_spool skipped reason=transport_unavailable')
+          return 0
+        end
+
+        # Read and truncate atomically under the mutex so no events written
+        # between read and truncate can be silently lost.
+        events = SPOOL_MUTEX.synchronize do
+          path = spool_file_path
+          return 0 unless File.exist?(path)
+
+          lines = File.readlines(path, chomp: true)
+          parsed = lines.filter_map do |line|
+            next if line.strip.empty?
+
+            Legion::JSON.load(line)
+          end
+          File.write(path, '')
+          parsed
+        end
+
+        return 0 if events.empty?
+
+        batch_sleep = spool_settings[:flush_batch_sleep] || 0.0
+        flushed = 0
+
+        events.each_with_index do |event_data, index|
+          event_class.new(**event_data).publish
+          flushed += 1
+          sleep(batch_sleep) if batch_sleep.positive? && index < events.size - 1
+        end
+
+        log.info("[llm][metering] flush_spool flushed=#{flushed}")
+        flushed
       rescue StandardError => e
         handle_exception(e, level: :warn, operation: 'llm.metering.flush_spool')
         0
@@ -128,6 +169,81 @@ module Legion
         hash[key] if hash.key?(key)
       end
 
+      # --- Spool internals (private) ---
+
+      def spool_event(event)
+        SPOOL_MUTEX.synchronize do
+          ensure_spool_dir
+          enforce_max_events
+          line = Legion::JSON.dump(event)
+          File.open(spool_file_path, 'a') { |f| f.puts(line) }
+        end
+        log.debug("[llm][metering] spool_event written provider=#{event[:provider]} model=#{event[:model_id]}")
+      rescue StandardError => e
+        handle_exception(e, level: :warn, operation: 'llm.metering.spool_event')
+      end
+
+      def read_spool
+        SPOOL_MUTEX.synchronize do
+          path = spool_file_path
+          return [] unless File.exist?(path)
+
+          lines = File.readlines(path, chomp: true)
+          lines.filter_map do |line|
+            next if line.strip.empty?
+
+            Legion::JSON.load(line)
+          end
+        end
+      rescue StandardError => e
+        handle_exception(e, level: :warn, operation: 'llm.metering.read_spool')
+        []
+      end
+
+      def truncate_spool
+        SPOOL_MUTEX.synchronize do
+          path = spool_file_path
+          File.write(path, '') if File.exist?(path)
+        end
+      rescue StandardError => e
+        handle_exception(e, level: :warn, operation: 'llm.metering.truncate_spool')
+      end
+
+      def enforce_max_events
+        path = spool_file_path
+        return unless File.exist?(path)
+
+        max = spool_settings[:max_events] || 10_000
+        lines = File.readlines(path, chomp: true)
+        return if lines.size < max
+
+        # Drop oldest events to make room
+        trimmed = lines.last(max - 1)
+        File.write(path, trimmed.map { |l| "#{l}\n" }.join)
+        log.debug("[llm][metering] enforce_max_events trimmed=#{lines.size - trimmed.size} max=#{max}")
+      end
+
+      def ensure_spool_dir
+        FileUtils.mkdir_p(spool_dir_path)
+      end
+
+      def spool_settings
+        settings = Legion::LLM::Settings.value(:metering, :spool, default: {})
+        settings.is_a?(Hash) ? settings : {}
+      end
+
+      # Resolve spool file path at call time, honouring operator-configured
+      # paths (e.g. for containerised deployments where $HOME is not writable).
+      # Falls back to the compile-time SPOOL_FILE constant.
+      def spool_file_path
+        configured = spool_settings[:path]
+        configured && !configured.to_s.strip.empty? ? configured.to_s : SPOOL_FILE
+      end
+
+      def spool_dir_path
+        File.dirname(spool_file_path)
+      end
+
       # Backward-compat: resolve old Legion::LLM::Metering::Exchange, ::Event
       def self.const_missing(name)
         case name

data/lib/legion/llm/router/health_tracker.rb

@@ -19,6 +19,7 @@ module Legion
           @circuits       = {}
           @latency_window = {}
           @handlers       = {}
+          @denied_models  = {}
           @mutex          = Mutex.new
 
           register_default_handlers
@@ -111,6 +112,42 @@ module Legion
           worst_circuit_state(instances)
         end
 
+        # Record that a model is denied for a provider+instance (e.g. AccessDenied).
+        # Excluded from routing until restart or explicit clear.
+        def deny_model(provider:, model:, instance: nil, reason: nil)
+          key = instance ? instance_key(provider, instance) : provider.to_s
+          @mutex.synchronize do
+            @denied_models[key] ||= {}
+            @denied_models[key][model.to_s] = { reason: reason, at: Time.now }
+          end
+          log.warn("Model denied provider=#{key} model=#{model} reason=#{reason}")
+        end
+
+        # Check if a model is denied for a provider+instance.
+        def model_denied?(provider:, model:, instance: nil)
+          key = instance ? instance_key(provider, instance) : provider.to_s
+          @mutex.synchronize do
+            !@denied_models.dig(key, model.to_s).nil?
+          end
+        end
+
+        # List all denied models (for diagnostics).
+        def denied_models
+          @mutex.synchronize { @denied_models.dup }
+        end
+
+        # Clear denied models for a provider (or all if no args).
+        def clear_denied(provider: nil, instance: nil)
+          @mutex.synchronize do
+            if provider
+              key = instance ? instance_key(provider, instance) : provider.to_s
+              @denied_models.delete(key)
+            else
+              @denied_models.clear
+            end
+          end
+        end
+
         # Clears circuit and latency data for a single provider.
         def reset(provider, instance: nil, offering_id: nil)
           key = instance ? instance_key(provider, instance) : health_key(provider, offering_id)
@@ -125,6 +162,7 @@ module Legion
           @mutex.synchronize do
             @circuits.clear
             @latency_window.clear
+            @denied_models.clear
           end
         end
 

data/lib/legion/llm/router.rb

@@ -163,7 +163,11 @@ module Legion
         end
 
         def explicit_resolution(tier, provider, model)
-          registry_entry = provider ? nil : registry_entry_for_tier(tier)
+          registry_entry = if provider
+                             registry_entry_for_provider(provider.to_sym)
+                           else
+                             registry_entry_for_tier(tier)
+                           end
           resolved_provider = provider ? provider.to_sym : (registry_entry&.[](:provider) || default_provider_for_tier(tier))
           resolved_model = model || registry_default_model(registry_entry) || default_model_for_tier(tier)
 
@@ -229,8 +233,11 @@ module Legion
                            memory_checked.reject { |r| excluded_by_caller?(r, normalized_exclude) }
                          end
 
+          # 4.7 Reject rules for models denied by health tracker
+          not_denied = not_excluded.reject { |r| excluded_by_denial?(r) }
+
           # 5. Filter by tier availability
-          final = not_excluded.select { |r| tier_available?(r.target[:tier] || r.target['tier']) }
+          final = not_denied.select { |r| tier_available?(r.target[:tier] || r.target['tier']) }
 
           log.debug("Router: #{final.size} candidates after filtering (started with #{rules.size})")
 
@@ -303,6 +310,15 @@ module Legion
           {}
         end
 
+        def excluded_by_denial?(rule)
+          provider = (rule.target[:provider] || rule.target['provider'])&.to_sym
+          model    = rule.target[:model] || rule.target['model']
+          instance = rule.target[:instance] || rule.target['instance']
+          return false unless provider && model
+
+          health_tracker.model_denied?(provider: provider, model: model, instance: instance)
+        end
+
         def excluded_by_caller?(rule, exclude)
           return false if exclude.nil? || exclude.empty?
 
@@ -397,22 +413,24 @@ module Legion
           # Fallback to static defaults
           case sym
           when :local, :direct, :fleet
-            'llama3'
+            default_settings_model_for_tier(sym) || 'llama3'
           when :openai_compat
             'gpt-4o'
           when :cloud
-            default_settings_model || 'us.anthropic.claude-sonnet-4-6'
+            default_settings_model_for_tier(sym) || 'us.anthropic.claude-sonnet-4-6'
           when :frontier
-            default_settings_model || 'claude-sonnet-4-6'
+            default_settings_model_for_tier(sym) || 'claude-sonnet-4-6'
           end
         end
 
         def chain_from_defaults(model, provider, max)
           if provider || model || default_settings_provider || default_settings_model
             p = (provider || default_settings_provider)&.to_sym
+            resolved_model = model || registry_default_model(registry_entry_for_provider(p)) ||
+                             default_settings_model || 'claude-sonnet-4-6'
             res = Resolution.new(tier:     PROVIDER_TIER.fetch(p, :frontier),
                                  provider: p || :anthropic,
-                                 model:    model || default_settings_model || 'claude-sonnet-4-6')
+                                 model:    resolved_model)
             return EscalationChain.new(resolutions: [res], max_attempts: max)
           end
 
@@ -512,6 +530,31 @@ module Legion
           Legion::LLM::Settings.value(:default_model)
         end
 
+        def default_settings_model_for_tier(tier)
+          model = default_settings_model
+          return nil if model.nil? || model.to_s.empty?
+
+          provider = default_settings_provider&.to_sym
+          return nil unless provider
+
+          provider_tier = registry_tier_for_default_provider(provider)
+          return model if provider_tier == tier
+
+          nil
+        end
+
+        def registry_tier_for_default_provider(provider)
+          instances = begin
+            Call::Registry.all_instances
+          rescue StandardError
+            []
+          end
+          entry = instances.find { |i| i[:provider] == provider }
+          return registry_tier(provider, entry[:metadata]) if entry
+
+          PROVIDER_TIER.fetch(provider, :cloud)
+        end
+
         def default_settings_provider
           Legion::LLM::Settings.value(:default_provider)
         end
@@ -529,6 +572,17 @@ module Legion
           registry_entry_for_tier(tier)&.[](:provider)
         end
 
+        # Find the first registered instance for a specific provider.
+        def registry_entry_for_provider(provider)
+          instances = begin
+            Call::Registry.all_instances
+          rescue StandardError => e
+            handle_exception(e, level: :warn, handled: true, operation: 'router.registry_entry_for_provider')
+            []
+          end
+          instances.find { |entry| entry[:provider] == provider }
+        end
+
         # Find a default model from registry for a given tier.
         # Tries adapter.offerings first, then metadata[:default_model].
         def registry_model_for_tier(tier)

data/lib/legion/llm/settings.rb

@@ -474,7 +474,7 @@ module Legion
           mode:             'auto',
           native_providers: %w[
             ollama vllm anthropic openai gemini mlx
-            bedrock azure_foundry vertex claude
+            bedrock azure_foundry vertex
           ]
         }
       end

data/lib/legion/llm/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module LLM
-    VERSION = '0.9.22'
+    VERSION = '0.9.23'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-llm
 version: !ruby/object:Gem::Version
-  version: 0.9.22
+  version: 0.9.23
 platform: ruby
 authors:
 - Esity