lex-llm-bedrock 0.4.4 → 0.4.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3aa9de1a3f3c07848fe253d6f8627c54b03bbc74bb96ab5032a407b109aad13a
-  data.tar.gz: a3f680546d15739bdfb84f79daa70a45beae2650893aead380e23b0e9086b38e
+  metadata.gz: ee19df358e0fe9b9c6020be38aca9500e1053aee94afd929e83b6a041dca82d5
+  data.tar.gz: 6d1ccabe1fa7709a941b1f679dad26ec49fa62950ca764d2fb07ffed1fa63c7b
 SHA512:
-  metadata.gz: 7b6ade385af00bbcd329278658f4fe829b312735f0141514353e4da0912d1002a9213cbd6f7411f4ba8dcad9dc9284adefe3518c17ff12297dd18d3f9db36d92
-  data.tar.gz: 0ffcee037a6efb318802b3ec1ad1684f0516ee133799dc420bd7a74883320c0c2029fc0df916757c5c4584386d4cc2f7cc5f5f8e7bfca46a8def152adfdb9e1f
+  metadata.gz: 9849e1efcf3a3d35ce2c9ea5c4b2fa61c5232a361b0a33c29f3deb6d98c1aad66672ffccafbebfdd94b4c353218befc12f39f0f13eba2b7429a0ab000d6ea4ab
+  data.tar.gz: db563c25558e547ac90bacc8d8dd4d0eb8628d8e3135063b32eaff6c48eddbcb128967cda735b4204eee6946b91d912852268f16167e261d8dfcbbfbcedd0f6d

data/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## [0.4.10] - 2026-08-04
+
+### Fixed
+- **Claude models now advertise the `:thinking` capability.** Discovery passed `provider_catalog: {}` to `CapabilityPolicy.resolve`, so per-model capabilities from the shared lex-llm catalog (which correctly tags Claude 3.7 / 4+ models `reasoning` → `:thinking`) were ignored — every Bedrock Claude model reported no thinking capability, so the router's thinking filter could not route thinking requests correctly. `offering_from_model` now consults the shared catalog via `catalog_capabilities`.
+- **Thinking payload no longer sends unsupported `adaptive` mode.** `invoke_model_thinking` / `build_invoke_thinking` (and the converse-path `bedrock_additional_fields` / `build_additional_fields`) previously emitted `{type: 'adaptive'}` for every non-`claude-sonnet-4` model, which Bedrock rejects with `ValidationException: adaptive thinking is not supported on this model` (HTTP 500, e.g. claude-opus-4-5). A new `ThinkingModes` module is the single source of truth shared by provider and translator: budgeted-thinking models emit `{type: 'enabled', budget_tokens: N}`; known non-thinking models omit thinking entirely. `adaptive` is never emitted.
+
+## [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

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.4'
+  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

@@ -6,6 +6,7 @@ require 'aws-sdk-bedrockruntime'
 require 'legion/json'
 require 'legion/logging/helper'
 require 'legion/extensions/llm'
+require_relative 'thinking_modes'
 
 module Legion
   module Extensions
@@ -66,6 +67,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 +87,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 +124,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 +142,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 +190,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:,
@@ -310,6 +306,42 @@ 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))
@@ -353,7 +385,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
@@ -425,7 +457,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)
@@ -479,7 +511,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)
@@ -589,7 +621,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
+              thinking_cfg = invoke_model_thinking(model: rest[:model] || model_id(rest[:model]), thinking: thinking)
+              body[:thinking] = thinking_cfg if thinking_cfg
+            end
             body
           end
 
@@ -609,11 +644,19 @@ 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)
+          # Emit the thinking wire shape the model actually supports.
+          # Budgeted-thinking Claude models get { type: 'enabled', budget_tokens: N }.
+          # Every other model returns nil so the caller OMITS the thinking field —
+          # Bedrock rejects { type: 'adaptive' } with a ValidationException (HTTP 500).
+          def invoke_model_thinking(model:, thinking:)
+            mid = model_id(model)
+            return nil if ThinkingModes.known_non_thinking?(mid)
 
-            thinking.except(:effort, 'effort')
+            budget = if thinking.is_a?(Hash)
+                       thinking[:budget_tokens] || thinking['budget_tokens'] ||
+                         thinking[:budget] || thinking['budget']
+                     end
+            { type: 'enabled', budget_tokens: budget }.compact
           end
 
           def format_invoke_model_messages(messages)
@@ -867,12 +910,19 @@ 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: {},
+              provider_catalog: catalog_capabilities(model),
               probe: {},
               provider_envelope: provider_envelope_capabilities,
               provider_config: provider_capability_config,
@@ -883,11 +933,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
 
@@ -908,9 +959,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,
@@ -921,7 +977,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
 
@@ -941,19 +998,19 @@ 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,
               tool_config: format_tool_config(tools, tool_prefs),
               guardrail_config: guardrail_config,
-              additional_model_request_fields: bedrock_additional_fields(thinking)
+              additional_model_request_fields: bedrock_additional_fields(thinking, model: model_id(model))
             }.compact
           end
 
-          def bedrock_additional_fields(thinking)
+          def bedrock_additional_fields(thinking, model:)
             fields = {}
-            if thinking
+            if thinking && !ThinkingModes.known_non_thinking?(model)
               fields[:thinking] = {
                 type: 'enabled',
                 budget_tokens: if thinking.is_a?(Hash)
@@ -1535,7 +1592,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
 
@@ -1545,7 +1601,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
 
@@ -1554,41 +1610,20 @@ 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')
+          # Capability truth from the shared lex-llm catalog (models.json), keyed by
+          # bedrock model id. This is the source of truth for per-model capabilities
+          # (e.g. :thinking for Claude 4+) that the live AWS ListFoundationModels
+          # summary does not expose. Surfaced to CapabilityPolicy as :provider_catalog
+          # so operator/instance/model overrides still win, and the boolean map is fed
+          # through the shared Capabilities alias table (reasoning -> :thinking).
+          def catalog_capabilities(model)
+            info = Legion::Extensions::Llm::Models.find(model.to_s, :bedrock)
+            caps = Legion::Extensions::Llm::Capabilities.normalize(info.capabilities)
+            caps.to_h { |cap| [cap, true] }
+          rescue Legion::Extensions::Llm::ModelNotFoundError
             {}
-          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')
+            handle_exception(e, level: :warn, handled: true, operation: 'bedrock.provider.catalog_capabilities')
             {}
           end
 

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Llm
+      module Bedrock
+        # Single source of truth for how each Bedrock model expresses extended
+        # thinking on the wire. Shared by both the Provider (invoke_model /
+        # converse paths) and the Translator (canonical render path) so the two
+        # never diverge.
+        #
+        # Bedrock supports exactly one thinking wire shape for Anthropic Claude:
+        #   { type: 'enabled', budget_tokens: N }   (native Anthropic Messages API)
+        #
+        # There is NO Bedrock Claude model that accepts { type: 'adaptive' } —
+        # sending adaptive raises `ValidationException: adaptive thinking is not
+        # supported on this model` (observed live on opus-4-5) and surfaces as an
+        # HTTP 500. So a model either supports budgeted thinking (emit `enabled`)
+        # or it does not (OMIT the thinking field entirely — never `adaptive`).
+        #
+        # Budgeted extended thinking arrived with Claude 3.7 Sonnet and is
+        # supported across the entire Claude 4 family (sonnet-4, opus-4.x,
+        # haiku-4.5). The match is a substring so it tolerates the many Bedrock
+        # model-id decorations (geo prefixes `us.`/`eu.`/`ap.`, `anthropic.`
+        # provider prefix, `-vN:0` version suffixes, `:200k` context suffixes).
+        module ThinkingModes
+          module_function
+
+          # Model-id fragments for Claude families that support explicit budgeted
+          # extended thinking via { type: 'enabled', budget_tokens: N }.
+          BUDGETED_THINKING_FRAGMENTS = %w[
+            claude-3-7-sonnet
+            claude-sonnet-4
+            claude-opus-4
+            claude-haiku-4
+          ].freeze
+
+          # @return [Boolean] true when the model supports { type: 'enabled', budget_tokens: N }
+          def budgeted_thinking?(model_id)
+            return false if model_id.nil? || model_id.to_s.strip.empty?
+
+            mid = model_id.to_s
+            # Substring scan (String#include?), NOT array intersection: intersect?
+            # raises TypeError on a String argument.
+            BUDGETED_THINKING_FRAGMENTS.any? { |fragment| mid.include?(fragment) }
+          end
+
+          # @return [Boolean] true when the model is KNOWN not to support thinking.
+          # Distinct from `!budgeted_thinking?`: a nil/blank/unknown model id is
+          # NOT known-unsupported — we then honor an explicit thinking request and
+          # emit the (safe) `enabled` shape rather than dropping it. The router's
+          # capability filter (fed by the shared catalog) is the real guard that
+          # keeps thinking requests off non-thinking models; this method only
+          # strips thinking for a positively-identified non-thinking Claude model
+          # so we never emit an unsupported shape and 500.
+          def known_non_thinking?(model_id)
+            return false if model_id.nil? || model_id.to_s.strip.empty?
+
+            !budgeted_thinking?(model_id)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,6 +3,7 @@
 require 'legion/json'
 require 'legion/logging/helper'
 require 'legion/extensions/llm/canonical'
+require_relative 'thinking_modes'
 
 module Legion
   module Extensions
@@ -20,8 +21,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 +152,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)
@@ -181,12 +179,18 @@ module Legion
 
           def build_additional_fields(canonical)
             return nil unless canonical.thinking
+            return nil if ThinkingModes.known_non_thinking?(model_from_request(canonical))
 
             budget = canonical_thinking_budget(canonical)
             budget ||= DEFAULT_MAX_TOKENS / 4
             { 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
 
@@ -251,8 +255,13 @@ module Legion
             body.compact
           end
 
+          # Emit the thinking wire shape the model supports. Budgeted-thinking
+          # Claude models get { type: 'enabled', budget_tokens: N }; every other
+          # model returns nil so render_invoke_model OMITS the thinking field.
+          # Bedrock rejects { type: 'adaptive' } (ValidationException -> HTTP 500).
           def build_invoke_thinking(canonical)
             return nil unless canonical.thinking
+            return nil if ThinkingModes.known_non_thinking?(model_from_request(canonical))
 
             budget = canonical_thinking_budget(canonical)
             budget ||= DEFAULT_MAX_TOKENS / 4

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module Bedrock
-        VERSION = '0.4.4'
+        VERSION = '0.4.10'
       end
     end
   end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'legion/extensions/llm'
+require 'legion/extensions/llm/bedrock/thinking_modes'
 require 'legion/extensions/llm/bedrock/provider'
 require 'legion/extensions/llm/bedrock/translator'
 require 'legion/extensions/llm/bedrock/version'
@@ -30,6 +31,7 @@ module Legion
             instance: {
               default_model: DEFAULT_MODEL,
               region: 'us-east-1',
+              geo_prefix: 'us',
               tier: :cloud,
               transport: :aws_sdk,
               credentials: {
@@ -41,6 +43,7 @@ module Legion
               },
               provider: {
                 region: DEFAULT_REGION,
+                geo_prefix: 'us',
                 endpoint: nil,
                 stub_responses: false
               },
@@ -85,9 +88,17 @@ module Legion
         # 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: config[:default_model], fallback: DEFAULT_MODEL,
-            **provider_class.model_policy(config, PROVIDER_FAMILY)
+            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
 
@@ -214,6 +225,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.4
+  version: 0.4.10
 platform: ruby
 authors:
 - LegionIO
@@ -99,14 +99,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.4
+        version: 0.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.4
+        version: 0.6.0
 description: Amazon Bedrock provider integration for the LegionIO LLM routing framework.
 email:
 - matthewdiverson@gmail.com
@@ -129,6 +129,7 @@ files:
 - lib/legion/extensions/llm/bedrock/actors/fleet_worker.rb
 - lib/legion/extensions/llm/bedrock/provider.rb
 - lib/legion/extensions/llm/bedrock/runners/fleet_worker.rb
+- lib/legion/extensions/llm/bedrock/thinking_modes.rb
 - lib/legion/extensions/llm/bedrock/translator.rb
 - lib/legion/extensions/llm/bedrock/version.rb
 homepage: https://github.com/LegionIO/lex-llm-bedrock