lex-llm-bedrock 0.4.9 → 0.4.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba738761ab28ad68c0dfb013b6f13c3d17ae587295a0b53f97e7bb091d8d4a65
-  data.tar.gz: 3b5d2b5955816d248773ce88d48d6f5719d06bb47bf8cba685eaef6cefb2bee2
+  metadata.gz: ee19df358e0fe9b9c6020be38aca9500e1053aee94afd929e83b6a041dca82d5
+  data.tar.gz: 6d1ccabe1fa7709a941b1f679dad26ec49fa62950ca764d2fb07ffed1fa63c7b
 SHA512:
-  metadata.gz: 99e05143e8194b69cdca989616d2f65f36807cc1d408fa4636eb98b688d76c8b5156c6864c6f7a391b601195aef667fb25e3086d2054f082f62f7dba995dd126
-  data.tar.gz: fd86abdaca844a0ea28f4b5e32041824fabd9dcf0e5870344045c5379ca776aa7b566a07bc1deb1480bd3c3f007146d1287f906abb66cf5c3df701661bf22e17
+  metadata.gz: 9849e1efcf3a3d35ce2c9ea5c4b2fa61c5232a361b0a33c29f3deb6d98c1aad66672ffccafbebfdd94b4c353218befc12f39f0f13eba2b7429a0ab000d6ea4ab
+  data.tar.gz: db563c25558e547ac90bacc8d8dd4d0eb8628d8e3135063b32eaff6c48eddbcb128967cda735b4204eee6946b91d912852268f16167e261d8dfcbbfbcedd0f6d

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # 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

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
@@ -621,8 +622,8 @@ module Legion
               body[:tool_choice] = tool_format[:tool_choice] if tool_format[:tool_choice]
             end
             if thinking
-              body[:thinking] =
-                invoke_model_thinking(model: rest[:model] || model_id(rest[:model]), thinking: 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
@@ -643,17 +644,19 @@ module Legion
             parts.map { |t| { type: 'text', text: t } }
           end
 
+          # 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)
-            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
+            return nil if ThinkingModes.known_non_thinking?(mid)
 
-            { type: 'adaptive' }
+            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)
@@ -919,7 +922,7 @@ module Legion
             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,
@@ -1001,13 +1004,13 @@ module Legion
               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)
@@ -1607,6 +1610,23 @@ module Legion
             { tools: true }
           end
 
+          # 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
+            {}
+          rescue StandardError => e
+            handle_exception(e, level: :warn, handled: true, operation: 'bedrock.provider.catalog_capabilities')
+            {}
+          end
+
           def model_family_for(model)
             normalize_provider(model.to_s.split('.').first)
           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
@@ -178,6 +179,7 @@ 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
@@ -253,17 +255,17 @@ 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))
 
-            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' }
+            budget = canonical_thinking_budget(canonical)
+            budget ||= DEFAULT_MAX_TOKENS / 4
+            { type: 'enabled', budget_tokens: budget }
           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.9'
+        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'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-bedrock
 version: !ruby/object:Gem::Version
-  version: 0.4.9
+  version: 0.4.10
 platform: ruby
 authors:
 - LegionIO
@@ -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