lex-llm-bedrock 0.4.3 → 0.4.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 05badbea355fec879dbd270070928472682c35d8709e3e6336e0080ca00aeb36
-  data.tar.gz: ec34813a7de565ad347c95777715054d27bd53ce71b04d8ddfd57de149852c9e
+  metadata.gz: ba738761ab28ad68c0dfb013b6f13c3d17ae587295a0b53f97e7bb091d8d4a65
+  data.tar.gz: 3b5d2b5955816d248773ce88d48d6f5719d06bb47bf8cba685eaef6cefb2bee2
 SHA512:
-  metadata.gz: '073218f79b092a425703aa62f45b8d07d69afcf01d1249b66435fa4dce7211f74cbfab184e7df61f506f92c0ca4322d1d8448e6317ed5d52870d699ff42757e9'
-  data.tar.gz: 415524d66dcb863b18036935b15b7965996adb249d78779845b6f53679e22745b9316a438de386e490051cf7c46af6bc3264cf3db24d2b7517a7c5c4d49c9375
+  metadata.gz: 99e05143e8194b69cdca989616d2f65f36807cc1d408fa4636eb98b688d76c8b5156c6864c6f7a391b601195aef667fb25e3086d2054f082f62f7dba995dd126
+  data.tar.gz: fd86abdaca844a0ea28f4b5e32041824fabd9dcf0e5870344045c5379ca776aa7b566a07bc1deb1480bd3c3f007146d1287f906abb66cf5c3df701661bf22e17

data/CHANGELOG.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## [0.4.9] - 2026-06-20
+
+### Fixed
+- Stub shared registry publishing through `RegistryPublisher#schedule` in specs so async availability-event coverage stays stable after the shared publisher moved off raw `Thread.new`.
+
+## [0.4.8] - 2026-06-20
+
+### Fixed
+- Stop bulk-publishing Bedrock model availability from `list_models`; discovery now emits one registry event per seen model from the shared `lex-llm` policy-filter path so blocked models stay observable without duplicate publishes.
+
+## [0.4.7] - 2026-06-20
+
+### Fixed
+- Stop deriving Bedrock `us.`/`eu.`/`ap.` inference-profile prefixes from AWS regions. Model invocation now strips any existing geo prefix and prepends only an explicit Bedrock geo prefix setting, defaulting to `us`.
+
+## [0.4.6] - 2026-06-20
+
+### Fixed
+- Canonicalize Bedrock embedding discovery to the shared singular `:embedding` capability and route provider/instance/model override extraction through the `lex-llm` base provider contract.
+
+## [0.4.5] - 2026-06-19
+
+### Changed
+- Adopt `Legion::Extensions::Llm::Inventory::ScopedRefresher` mixin (lex-llm 0.6.0). Discovery
+  refresh actors now write directly to the live `Inventory` catalog via `Inventory.write_lane`.
+- Pin `lex-llm >= 0.6.0` and `legion-llm >= 0.14.0` in gemspec.
+- Standard `weight: 100` default added to provider instance settings schema.
+
+## 0.4.4 - 2026-06-17
+
+### Fixed
+- **Model policy enforced at dispatch (compliance)** — Bedrock overrides the base dispatch methods (`chat`, `stream`, `embed`), so the base `enforce_model_allowed!` guard did not apply. Each override now calls `enforce_model_allowed!(model_id(model))`, raising `ModelNotAllowedError` before any Bedrock API call when the model is excluded by `model_whitelist`/`model_blacklist`. Fail-closed, no exceptions.
+
+### Changed
+- **Policy-aware default model** — the `anthropic.claude-sonnet-4` default is no longer a hardcoded literal forced via `||=`; it is a named `DEFAULT_MODEL` constant resolved through `Provider.policy_safe_default_model`, so a configured whitelist/blacklist is never overridden by the fallback. Requires lex-llm >= 0.5.4.
+
 ## 0.4.3 - 2026-06-16
 
 - Dependency updates and code quality improvements.

data/lex-llm-bedrock.gemspec

@@ -29,5 +29,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'legion-logging', '>= 1.3.2'
   spec.add_dependency 'legion-settings', '>= 1.3.14'
   spec.add_dependency 'legion-transport', '>= 1.4.14'
-  spec.add_dependency 'lex-llm', '>= 0.5.0'
+  spec.add_dependency 'lex-llm', '>= 0.6.0'
 end

data/lib/legion/extensions/llm/bedrock/actors/discovery_refresh.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'digest'
+
 begin
   require 'legion/extensions/actors/every'
 rescue LoadError => e
@@ -8,15 +10,27 @@ end
 
 return unless defined?(Legion::Extensions::Actors::Every)
 
+begin
+  require 'legion/extensions/llm/inventory/scoped_refresher'
+rescue LoadError => e
+  warn(e.message) if $VERBOSE
+end
+
 module Legion
   module Extensions
     module Llm
       module Bedrock
         module Actor
-          class DiscoveryRefresh < Legion::Extensions::Actors::Every # rubocop:disable Style/Documentation
+          class DiscoveryRefresh < Legion::Extensions::Actors::Every # rubocop:disable Style/Documentation,Metrics/ClassLength
             include Legion::Logging::Helper
 
-            REFRESH_INTERVAL = 1800
+            if defined?(Legion::Extensions::Llm::Inventory::ScopedRefresher)
+              include Legion::Extensions::Llm::Inventory::ScopedRefresher
+            end
+
+            EMBED_TYPES = %i[embed embedding].freeze
+
+            def self.every_seconds = 3600
 
             def runner_class    = self.class
             def runner_function = 'manual'
@@ -26,26 +40,117 @@ module Legion
             def generate_task?  = false
 
             def time
-              return REFRESH_INTERVAL unless defined?(Legion::Settings)
+              return self.class.every_seconds unless defined?(Legion::Settings)
+
+              Legion::Settings.dig(:extensions, :llm, :bedrock, :discovery_interval) || self.class.every_seconds
+            end
 
-              Legion::Settings.dig(:extensions, :llm, :bedrock, :discovery_interval) || REFRESH_INTERVAL
+            def scope_key(**)
+              { provider: :bedrock }
             end
 
-            def manual
-              log.debug('[bedrock][discovery_refresh] refreshing model list')
-              return unless defined?(Legion::LLM::Discovery)
+            def compute_lanes_for_scope(**)
+              return [] unless defined?(Legion::LLM::Call::Registry)
 
-              Legion::LLM::Discovery.refresh_discovered_models!(provider: :bedrock)
+              settings = Legion::Settings.dig(:extensions, :llm, :bedrock) || {}
+              fleet_enabled = settings.dig(:fleet, :dispatch, :enabled)
 
-              if defined?(Legion::LLM::Router) && Legion::LLM::Router.respond_to?(:populate_auto_rules)
-                Legion::LLM::Router.populate_auto_rules(Legion::LLM::Discovery.discovered_instances)
-              end
-              if defined?(Legion::LLM::Inventory) && Legion::LLM::Inventory.respond_to?(:invalidate_offerings_cache!)
-                Legion::LLM::Inventory.invalidate_offerings_cache!
+              instances = Legion::LLM::Call::Registry.all_instances.select do |e|
+                (e[:provider] || '').to_sym == :bedrock
               end
+
+              instances.flat_map { |inst| lanes_for_instance(inst, fleet_enabled: fleet_enabled) }
+            rescue StandardError => e
+              handle_exception(e, level: :warn, handled: true,
+                                  operation: 'bedrock.actor.discovery_refresh.compute_lanes')
+              []
+            end
+
+            def credential_hash(**)
+              raw = Legion::Settings.dig(:extensions, :llm, :bedrock) || {}
+              Digest::SHA256.hexdigest(raw[:api_key].to_s + raw[:instances].to_s)[0, 16]
+            end
+
+            def manual(**)
+              tick if defined?(Legion::Extensions::Llm::Inventory::ScopedRefresher) &&
+                      self.class.ancestors.include?(Legion::Extensions::Llm::Inventory::ScopedRefresher)
             rescue StandardError => e
               handle_exception(e, level: :warn, handled: true, operation: 'bedrock.actor.discovery_refresh')
             end
+
+            private
+
+            def lanes_for_instance(instance, fleet_enabled: false)
+              adapter = instance[:adapter]
+              return [] unless adapter.respond_to?(:discover_offerings)
+
+              Array(adapter.discover_offerings(live: true)).flat_map do |raw_offering|
+                offering = offering_to_hash(raw_offering)
+                next [] unless offering
+
+                build_offering_lanes(offering, instance, fleet_enabled: fleet_enabled)
+              end
+            end
+
+            def offering_to_hash(offering)
+              return nil if offering.nil?
+              return offering if offering.is_a?(Hash)
+
+              hash = offering.to_h
+              hash[:type] ||= hash[:usage_type]
+              hash[:enabled] = offering.respond_to?(:enabled?) ? offering.enabled? : true
+              hash
+            end
+
+            def build_offering_lanes(offering, instance, fleet_enabled: false)
+              raw_tier = offering[:tier] || :cloud
+              type = EMBED_TYPES.include?(offering[:type]&.to_sym) ? :embedding : :inference
+
+              lane_fields = {
+                tier: raw_tier,
+                provider_family: :bedrock,
+                instance_id: instance[:instance] || instance[:instance_id] || instance[:id] || 'default',
+                type: type,
+                model: offering[:model]
+              }
+
+              lane = build_lane(offering, lane_fields)
+              result = [lane]
+
+              if fleet_enabled && type == :inference
+                fleet_fields = lane_fields.merge(tier: :fleet)
+                result << lane.merge(
+                  id: Legion::Extensions::Llm::Inventory::ScopedRefresher.compose_id(fleet_fields),
+                  tier: :fleet
+                )
+              end
+
+              result
+            end
+
+            def build_lane(offering, lane_fields)
+              capabilities = normalize_capabilities(offering[:capabilities])
+              {
+                id: Legion::Extensions::Llm::Inventory::ScopedRefresher.compose_id(lane_fields),
+                tier: lane_fields[:tier],
+                provider_family: :bedrock,
+                instance_id: lane_fields[:instance_id],
+                model: offering[:model],
+                canonical_model_alias: offering[:canonical_model_alias],
+                type: lane_fields[:type],
+                capabilities: capabilities,
+                limits: offering[:limits] || {},
+                enabled: offering.fetch(:enabled, true),
+                cost: offering[:cost] || {}
+              }
+            end
+
+            def normalize_capabilities(caps)
+              return [] unless defined?(Legion::Extensions::Llm::Inventory::Capabilities)
+              return [] unless Legion::Extensions::Llm::Inventory::Capabilities.respond_to?(:normalize)
+
+              Legion::Extensions::Llm::Inventory::Capabilities.normalize(caps)
+            end
           end
         end
       end

data/lib/legion/extensions/llm/bedrock/provider.rb

@@ -66,6 +66,7 @@ module Legion
                 bedrock_access_key_id
                 bedrock_secret_access_key
                 bedrock_session_token
+                bedrock_geo_prefix
                 bedrock_profile
                 bedrock_stub_responses
                 bearer_token
@@ -85,24 +86,19 @@ module Legion
 
             INFERENCE_PROFILE_PREFIXES = %w[anthropic. meta. mistral. cohere. ai21.].freeze
 
-            def inference_profile_id(model, region: nil)
-              return model if model.start_with?('us.', 'eu.', 'ap.', 'arn:')
-              return model unless INFERENCE_PROFILE_PREFIXES.any? { |p| model.start_with?(p) }
+            def inference_profile_id(model, geo_prefix: 'us', region: nil)
+              return model if model.start_with?('arn:')
 
-              prefix = region ? region_prefix(region) : 'us'
-              "#{prefix}.#{model}"
-            end
+              canonical = model.sub(/\A(?:us|eu|ap)\./, '')
+              return canonical unless INFERENCE_PROFILE_PREFIXES.any? { |p| canonical.start_with?(p) }
 
-            # Region-based inference profile prefix mapping.
-            # Bare model IDs (e.g. anthropic.claude-sonnet-4) get the region prefix.
-            REGION_PREFIX = {
-              'us-east-1' => 'us', 'us-east-2' => 'us', 'us-west-1' => 'us', 'us-west-2' => 'us',
-              'eu-central-1' => 'eu', 'eu-west-1' => 'eu', 'eu-west-2' => 'eu', 'eu-west-3' => 'eu',
-              'ap-south-1' => 'ap', 'ap-southeast-1' => 'ap', 'ap-southeast-2' => 'ap', 'ap-northeast-1' => 'ap'
-            }.freeze
+              prefix = normalize_geo_prefix(geo_prefix || region)
+              "#{prefix}.#{canonical}"
+            end
 
-            def region_prefix(region)
-              REGION_PREFIX.fetch(region.to_s, 'us')
+            def normalize_geo_prefix(value)
+              candidate = value.to_s.downcase
+              %w[us eu ap].include?(candidate) ? candidate : 'us'
             end
           end
 
@@ -127,6 +123,10 @@ module Legion
             @translator ||= Translator.new(region: region)
           end
 
+          def settings
+            Bedrock.default_settings
+          end
+
           def api_base
             config.bedrock_endpoint || "https://bedrock-runtime.#{region}.amazonaws.com"
           end
@@ -141,25 +141,9 @@ module Legion
             config.bedrock_region || settings[:region] || 'us-east-1'
           end
 
-          def discover_offerings(live: false, **filters)
-            unless live
-              return @cached_offerings if @cached_offerings&.any?
-
-              log.debug { 'bedrock.provider.discover_offerings: returning static catalog' }
-              return static_offerings(**filters)
-            end
-
-            log.info { "bedrock.provider.discover_offerings: listing foundation models (region=#{region})" }
-            response = bedrock_client.list_foundation_models(**filters)
-            @cached_offerings = Array(value(response, :model_summaries)).filter_map do |summary|
-              offering = offering_from_summary(summary)
-              model_id = offering.respond_to?(:model) ? offering.model : (offering[:model] || offering[:id])
-              next unless model_allowed?(model_id.to_s)
-
-              offering
-            end
-            log.info { "bedrock.provider.discover_offerings: found #{@cached_offerings.size} models" }
-            @cached_offerings
+          def geo_prefix
+            configured = config.bedrock_geo_prefix if config.respond_to?(:bedrock_geo_prefix)
+            self.class.normalize_geo_prefix(configured || settings[:geo_prefix])
           end
 
           def offering_for(model:, model_family: nil, instance_id: :default, **metadata)
@@ -205,15 +189,26 @@ module Legion
             end
           end
 
-          def list_models(**)
+          def list_models(**filters)
+            request_filters = {}
+            request_filters[:by_provider] = filters[:by_provider] if filters[:by_provider]
+
             log.info { 'bedrock.provider.list_models: fetching live model list' }
-            response = bedrock_client.list_foundation_models
+            response = bedrock_client.list_foundation_models(**request_filters)
             models = Array(value(response, :model_summaries)).filter_map { |summary| model_info_from_summary(summary) }
             log.info { "bedrock.provider.list_models: found #{models.size} models" }
-            self.class.registry_publisher.publish_models_async(models, readiness: readiness(live: false))
             models
           end
 
+          def discover_offerings(live: false, **filters)
+            return static_offerings(**filters) unless live
+
+            provider_health = health(live:)
+            @cached_offerings = discover_live_offerings(filters, provider_health, live:)
+            log_discover_complete(@cached_offerings)
+            @cached_offerings
+          end
+
           def chat(
             messages:,
             model:,
@@ -225,6 +220,7 @@ module Legion
             thinking: nil,
             **_provider_options
           )
+            enforce_model_allowed!(model_id(model))
             log.info { "bedrock.provider.chat: model=#{model_id(model)} messages=#{messages.size}" }
 
             # Bedrock Converse API silently drops thinking config and tool_use blocks
@@ -309,8 +305,45 @@ module Legion
             parse_converse_response(response, model_id(model))
           end
 
+          def discovery_registry_readiness(provider_health, live:)
+            {
+              provider: slug.to_sym,
+              configured: configured?,
+              ready: provider_health[:ready] == true,
+              live: live,
+              health: provider_health
+            }
+          end
+
+          def discover_live_offerings(filters, provider_health, live:)
+            readiness = discovery_registry_readiness(provider_health, live:)
+            Array(list_models(live:, **filters)).filter_map do |model|
+              self.class.registry_publisher.publish_models_async([model], readiness:)
+              next unless model_matches_filters?(model, filters)
+              next unless model_allowed?(model.id)
+
+              log_model_discovered(model)
+              offering_from_model(model, health: provider_health)
+            end
+          end
+
+          def log_model_discovered(model)
+            log.debug(
+              "[#{slug}] instance=#{provider_instance_id} action=model_discovered " \
+              "model=#{model.id} family=#{model.family}"
+            )
+          end
+
+          def log_discover_complete(offerings)
+            log.info(
+              "[#{slug}] instance=#{provider_instance_id} action=discover_complete " \
+              "model_count=#{Array(offerings).size}"
+            )
+          end
+
           def stream(messages:, model:, temperature: nil, max_tokens: nil, tools: {}, tool_prefs: nil, params: {},
                      thinking: nil, **_provider_options, &)
+            enforce_model_allowed!(model_id(model))
             log.info do
               "bedrock.provider.stream: model=#{model_id(model)} messages=#{messages.size} tools=#{tools.size}"
             end
@@ -351,7 +384,7 @@ module Legion
             log.debug { "bedrock.provider.count_tokens: model=#{model_id(model)}" }
             request = Utils.deep_merge(
               {
-                model_id: self.class.inference_profile_id(model_id(model), region: region),
+                model_id: self.class.inference_profile_id(model_id(model), geo_prefix: geo_prefix),
                 input: { converse: { messages: format_messages(messages), system: system_blocks(system) }.compact }
               },
               params
@@ -368,6 +401,7 @@ module Legion
             **_provider_options
           )
             mid = model_id(model)
+            enforce_model_allowed!(mid)
             unless titan_embed?(mid)
               raise NotImplementedError,
                     "Bedrock embedding payload for #{mid} is not standardized"
@@ -422,7 +456,7 @@ module Legion
             log.debug { "bedrock.provider.invoke_model_chat: model=#{mid} thinking=#{thinking.inspect}" }
 
             response = runtime_client.invoke_model(
-              model_id: self.class.inference_profile_id(mid, region: region),
+              model_id: self.class.inference_profile_id(mid, geo_prefix: geo_prefix),
               content_type: 'application/json',
               accept: 'application/json',
               body: Legion::JSON.generate(body)
@@ -476,7 +510,7 @@ module Legion
 
             # rubocop:disable Metrics/BlockLength
             runtime_client.invoke_model_with_response_stream(
-              model_id: self.class.inference_profile_id(mid, region: region),
+              model_id: self.class.inference_profile_id(mid, geo_prefix: geo_prefix),
               content_type: 'application/json',
               accept: 'application/json',
               body: Legion::JSON.generate(body)
@@ -586,7 +620,10 @@ module Legion
               body[:tools] = tool_format[:tools]
               body[:tool_choice] = tool_format[:tool_choice] if tool_format[:tool_choice]
             end
-            body[:thinking] = invoke_model_thinking(thinking) if thinking
+            if thinking
+              body[:thinking] =
+                invoke_model_thinking(model: rest[:model] || model_id(rest[:model]), thinking: thinking)
+            end
             body
           end
 
@@ -606,11 +643,17 @@ module Legion
             parts.map { |t| { type: 'text', text: t } }
           end
 
-          # Strip provider-specific keys (e.g. effort from OpenAI) that Bedrock/Anthropic APIs don't accept.
-          def invoke_model_thinking(thinking)
-            return thinking unless thinking.is_a?(Hash)
+          def invoke_model_thinking(model:, thinking:)
+            mid = model_id(model)
+            if mid.include?('claude-sonnet-4')
+              budget = if thinking.is_a?(Hash)
+                         thinking[:budget_tokens] || thinking['budget_tokens'] ||
+                           thinking[:budget] || thinking['budget']
+                       end
+              return { type: 'enabled', budget_tokens: budget }.compact
+            end
 
-            thinking.except(:effort, 'effort')
+            { type: 'adaptive' }
           end
 
           def format_invoke_model_messages(messages)
@@ -864,9 +907,16 @@ module Legion
             end
           end
 
-          def offering_from_summary(summary)
-            model = value(summary, :model_id)
-            real = real_capabilities_from_summary(summary)
+          def offering_from_model(model_info, health: {})
+            model = model_info.respond_to?(:id) ? model_info.id : model_info
+            real = if model_info.respond_to?(:capabilities)
+                     Array(model_info.capabilities).to_h do |capability|
+                       [capability.to_s.downcase.tr('-', '_').to_sym, true]
+                     end
+                   else
+                     {}
+                   end
+            metadata = model_info.respond_to?(:metadata) && model_info.metadata.is_a?(Hash) ? model_info.metadata : {}
             policy = Legion::Extensions::Llm::CapabilityPolicy.resolve(
               real: real,
               provider_catalog: {},
@@ -880,11 +930,12 @@ module Legion
             build_offering(
               model: model,
               alias_name: alias_for(model),
-              model_family: normalize_provider(value(summary, :provider_name)) || model_family_for(model),
-              usage_type: usage_type_from_modalities(value(summary, :output_modalities)),
+              model_family: model_info.respond_to?(:family) ? model_info.family : model_family_for(model),
+              usage_type: model_info.respond_to?(:embedding?) && model_info.embedding? ? :embedding : :inference,
               capabilities: policy[:capabilities],
               capability_sources: policy[:sources],
-              metadata: normalize_response(summary)
+              metadata: metadata,
+              health: health
             )
           end
 
@@ -905,9 +956,14 @@ module Legion
             )
           end
 
+          def offering_from_summary(summary, health: {})
+            offering_from_model(model_info_from_summary(summary), health:)
+          end
+
           def build_offering(model:, model_family:, usage_type:, instance_id: :default, alias_name: nil,
-                             capabilities: nil, capability_sources: nil, metadata: {})
+                             capabilities: nil, capability_sources: nil, metadata: {}, health: {})
             limits = infer_limits(model)
+            normalized_family = model_family&.to_sym
             Legion::Extensions::Llm::Routing::ModelOffering.new(
               provider_family: :bedrock,
               instance_id: instance_id,
@@ -918,7 +974,8 @@ module Legion
               capabilities: capabilities || default_capabilities(model),
               capability_sources: capability_sources,
               limits: limits,
-              metadata: metadata.merge(model_family: model_family, alias: alias_name).compact
+              health: health,
+              metadata: metadata.merge(model_family: normalized_family, alias: alias_name).compact
             )
           end
 
@@ -938,7 +995,7 @@ module Legion
           def converse_request(messages, model:, temperature:, max_tokens:, tools:, tool_prefs:, guardrail_config: nil,
                                thinking: nil)
             {
-              model_id: self.class.inference_profile_id(model_id(model), region: region),
+              model_id: self.class.inference_profile_id(model_id(model), geo_prefix: geo_prefix),
               messages: format_messages(messages.reject { |message| message.role == :system }),
               system: format_system(messages),
               inference_config: { temperature: temperature, max_tokens: max_tokens || model_max_tokens(model) }.compact,
@@ -1532,7 +1589,6 @@ module Legion
               caps << :streaming if value(summary, :response_streaming_supported)
             end
             caps << :vision if input_mods.include?('image')
-            caps << :tools if caps.include?(:completion)
             caps
           end
 
@@ -1542,7 +1598,7 @@ module Legion
             input_mods = Array(value(summary, :input_modalities)).map { |m| m.to_s.upcase }
             caps[:vision] = true if input_mods.include?('IMAGE')
             output_mods = Array(value(summary, :output_modalities)).map { |m| m.to_s.upcase }
-            caps[:embeddings] = true if output_mods.include?('EMBEDDING')
+            caps[:embedding] = true if output_mods.include?('EMBEDDING')
             caps
           end
 
@@ -1551,44 +1607,6 @@ module Legion
             { tools: true }
           end
 
-          def provider_capability_config
-            return {} unless defined?(Legion::Extensions::Llm::CredentialSources)
-
-            conf = Legion::Extensions::Llm::CredentialSources.setting(:extensions, :llm, :bedrock)
-            conf.is_a?(Hash) ? conf.to_h.except(:instances, 'instances') : {}
-          rescue StandardError => e
-            handle_exception(e, level: :debug, handled: true, operation: 'bedrock.provider_capability_config')
-            {}
-          end
-
-          def instance_capability_config
-            cfg = config
-            result = {}
-            %i[capabilities enable_thinking enable_tools enable_streaming enable_vision enable_embeddings
-               thinking_flag tools_flag streaming_flag vision_flag embedding_flag embeddings_flag
-               tool_flag images_flag image_flag].each do |key|
-              next unless cfg.respond_to?(key)
-
-              val = cfg.send(key)
-              result[key] = val unless val.nil?
-            rescue StandardError
-              next
-            end
-            result
-          end
-
-          def model_capability_config(model_id)
-            models_conf = nil
-            models_conf = config.models if config.respond_to?(:models)
-            models_conf ||= config[:models] if config.respond_to?(:[])
-            return {} unless models_conf.respond_to?(:to_h)
-
-            models_conf.to_h[model_id.to_s] || models_conf.to_h[model_id.to_sym] || {}
-          rescue StandardError => e
-            handle_exception(e, level: :debug, handled: true, operation: 'bedrock.model_capability_config')
-            {}
-          end
-
           def model_family_for(model)
             normalize_provider(model.to_s.split('.').first)
           end

data/lib/legion/extensions/llm/bedrock/translator.rb

@@ -20,8 +20,9 @@ module Legion
 
           DEFAULT_MAX_TOKENS = 4096
 
-          def initialize(region: nil)
+          def initialize(region: nil, geo_prefix: nil)
             @region = region
+            @geo_prefix = geo_prefix
           end
 
           def capabilities
@@ -150,17 +151,13 @@ module Legion
           end
 
           def inference_profile_id(model_id)
-            return model_id if model_id.nil? || model_id.start_with?('us.', 'eu.', 'ap.', 'arn:')
+            return model_id if model_id.nil? || model_id.start_with?('arn:')
 
-            return model_id unless MODEL_PREFIXED_FAMILIES.any? { |p| model_id.start_with?(p) }
+            canonical = model_id.sub(/\A(?:us|eu|ap)\./, '')
+            return canonical unless MODEL_PREFIXED_FAMILIES.any? { |p| canonical.start_with?(p) }
 
-            region = @region || 'us-east-1'
-            prefix = if region.include?('eu')
-                       'eu'
-                     else
-                       region.include?('ap') ? 'ap' : 'us'
-                     end
-            "#{prefix}.#{model_id}"
+            prefix = normalize_geo_prefix(@geo_prefix)
+            "#{prefix}.#{canonical}"
           end
 
           def build_inference_config(canonical)
@@ -187,6 +184,11 @@ module Legion
             { thinking: { type: 'enabled', budget_tokens: budget } }
           end
 
+          def normalize_geo_prefix(value)
+            candidate = value.to_s.downcase
+            %w[us eu ap].include?(candidate) ? candidate : 'us'
+          end
+
           def canonical_thinking_budget(canonical)
             return nil unless canonical.thinking
 
@@ -254,9 +256,14 @@ module Legion
           def build_invoke_thinking(canonical)
             return nil unless canonical.thinking
 
-            budget = canonical_thinking_budget(canonical)
-            budget ||= DEFAULT_MAX_TOKENS / 4
-            { type: 'enabled', budget_tokens: budget }
+            model = model_from_request(canonical)
+            if model.to_s.include?('claude-sonnet-4')
+              budget = canonical_thinking_budget(canonical)
+              budget ||= DEFAULT_MAX_TOKENS / 4
+              return { type: 'enabled', budget_tokens: budget }
+            end
+
+            { type: 'adaptive' }
           end
 
           def render_invoke_system(canonical)

data/lib/legion/extensions/llm/bedrock/version.rb

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module Bedrock
-        VERSION = '0.4.3'
+        VERSION = '0.4.9'
       end
     end
   end

data/lib/legion/extensions/llm/bedrock.rb

@@ -19,13 +19,18 @@ module Legion
         PROVIDER_FAMILY = :bedrock
 
         DEFAULT_REGION = 'us-east-2'
+        # Provider's preferred default when the operator configures none. Used only
+        # as a fallback and only when the configured model policy permits it
+        # (see resolve_default_model) — a whitelist/blacklist is never overridden.
+        DEFAULT_MODEL = 'anthropic.claude-sonnet-4'
 
         def self.default_settings
           ::Legion::Extensions::Llm.provider_settings(
             family: PROVIDER_FAMILY,
             instance: {
-              default_model: 'anthropic.claude-sonnet-4',
+              default_model: DEFAULT_MODEL,
               region: 'us-east-1',
+              geo_prefix: 'us',
               tier: :cloud,
               transport: :aws_sdk,
               credentials: {
@@ -37,6 +42,7 @@ module Legion
               },
               provider: {
                 region: DEFAULT_REGION,
+                geo_prefix: 'us',
                 endpoint: nil,
                 stub_responses: false
               },
@@ -73,11 +79,28 @@ module Legion
                            .transform_values do |config|
             sanitized = sanitize_instance_config(config)
             sanitized[:capabilities] ||= DEFAULT_CAPABILITIES.dup
-            sanitized[:default_model] ||= 'anthropic.claude-sonnet-4'
+            sanitized[:default_model] = resolve_default_model(sanitized)
             sanitized
           end
         end
 
+        # Resolve a default_model that never violates the configured model policy
+        # (whitelist/blacklist stays authoritative over the DEFAULT_MODEL fallback).
+        def self.resolve_default_model(config)
+          cfg = config.is_a?(Hash) ? config : {}
+          provider_conf = CredentialSources.setting(:extensions, :llm, PROVIDER_FAMILY)
+          provider_conf = {} unless provider_conf.is_a?(Hash)
+          global_conf = (::Legion::Settings.dig(:extensions, :llm) if defined?(::Legion::Settings))
+          global_conf = {} unless global_conf.is_a?(Hash)
+
+          provider_class.policy_safe_default_model(
+            configured: cfg[:default_model],
+            fallback: DEFAULT_MODEL,
+            whitelist: provider_class.resolve_policy_value(cfg, provider_conf, global_conf, :model_whitelist),
+            blacklist: provider_class.resolve_policy_value(cfg, provider_conf, global_conf, :model_blacklist)
+          )
+        end
+
         def self.unresolved_credential?(config)
           return false if config[:bedrock_profile]
 
@@ -201,6 +224,7 @@ module Legion
 
           normalized = config.to_h.transform_keys { |key| key.respond_to?(:to_sym) ? key.to_sym : key }
           normalized[:bedrock_region] ||= normalized.delete(:region)
+          normalized[:bedrock_geo_prefix] ||= normalized.delete(:geo_prefix)
           normalized[:bedrock_endpoint] ||= normalized.delete(:endpoint)
           normalized[:bedrock_endpoint] ||= normalized.delete(:base_url)
           normalized[:bedrock_endpoint] ||= normalized.delete(:api_base)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-bedrock
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.4.9
 platform: ruby
 authors:
 - LegionIO
@@ -99,14 +99,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.6.0
 description: Amazon Bedrock provider integration for the LegionIO LLM routing framework.
 email:
 - matthewdiverson@gmail.com