lex-llm-bedrock 0.3.19 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33ab4ab57335007d1ffd9ef1c641e9be4fa657d83129f0b51382f624c3279fb3
-  data.tar.gz: 74e962cef7be3018f94a296d84ff248de09d9c0dc88ce1ddb9de8fcb3bf32e21
+  metadata.gz: 05badbea355fec879dbd270070928472682c35d8709e3e6336e0080ca00aeb36
+  data.tar.gz: ec34813a7de565ad347c95777715054d27bd53ce71b04d8ddfd57de149852c9e
 SHA512:
-  metadata.gz: 0d70d7113fa2b52ded5f4f64a49711052de15f8389c55840e8b4dcbc576b4b7cb55ad4f4bdb5255eb31c9e3e04b83a05415b56e6a4f8b65be31541ff3e5d4ad1
-  data.tar.gz: 0ee5829d8287dec6cfa825454a2b36aef4218e7e14517cbc1cf358eac689fdee82462d7031e45c22e3f76160dca2a2b0f1e3de291d6f95c597a97eccef483044
+  metadata.gz: '073218f79b092a425703aa62f45b8d07d69afcf01d1249b66435fa4dce7211f74cbfab184e7df61f506f92c0ca4322d1d8448e6317ed5d52870d699ff42757e9'
+  data.tar.gz: 415524d66dcb863b18036935b15b7965996adb249d78779845b6f53679e22745b9316a438de386e490051cf7c46af6bc3264cf3db24d2b7517a7c5c4d49c9375

data/.rubocop.yml

@@ -8,6 +8,10 @@ AllCops:
   TargetRubyVersion: 3.4
   SuggestExtensions: false
 
+Lint/ShadowedException:
+  Enabled: false
+Lint/UselessConstantScoping:
+  Enabled: false
 Metrics/BlockLength:
   Exclude:
     - "*.gemspec"

data/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## 0.4.3 - 2026-06-16
+
+- Dependency updates and code quality improvements.
+
+## 0.4.2 - 2026-06-15
+
+- **CapabilityPolicy integration** — AWS model summaries used as `:model_metadata`; Converse tool use from `:provider_envelope`. Settings overrides at provider/instance/model level supported.
+
+## 0.4.1 - 2026-06-13
+
+- **Gemfile cleanup** — Remove local path overrides; dependencies resolve from gemspec via rubygems.
+- **RuboCop fixes** — Auto-corrected 6 offenses (style/layout).
+- 199 examples, 0 failures; 17 files, 0 rubocop offenses.
+
+## 0.4.0 - 2026-06-10
+
+### Added
+- **Canonical provider translator** — New `Legion::Extensions::Llm::Bedrock::Translator` class implementing the canonical translator interface per Phase 3 of the N×N routing design. Supports `render_request`, `parse_response`, `parse_chunk`, and `capabilities`. Extracted from existing `format_messages`, `format_tools`, `parse_*` provider code (provider.rb) — move and normalize, no semantic rewrites.
+- **Dual render targets** — Translator renders canonical requests to both Bedrock Converse API (`:converse`) and Bedrock invoke_model with Anthropic Messages payload (`:invoke_model`). Auto-selection: Anthropic models with thinking or tools route through invoke_model, all other requests use Converse.
+- **Conformance kit adoption** — Loads `it_behaves_like 'a canonical provider translator'` shared examples from lex-llm. Full fixture-driven conformance with simple text, system prompt, params, tools, thinking, multi-turn continuation, streaming (text/thinking/tool call), error, stop_reason mapping, and round-trip consistency.
+- **Canonical capabilities declaration** — `capabilities` declares `provider: 'bedrock'`, `render_targets: [:converse, :invoke_model]`, `thinking: :budget_tokens`, `stop_reasons` mapping (including `guardrail_intervened` → `content_filter`).
+
+### Changed
+- **lex-llm dependency** — Bumped to `lex-llm >= 0.5.0` for canonical types (Request/Response/Chunk/Params/Thinking/ToolCall/Usage/Message/ContentBlock/ToolDefinition) and conformance kit availability.
+- **Version bump** — Minor version 0.3.x → 0.4.0 (additive feature release).
+
+### Fixed
+- **Params handling** — Translator uses `Canonical::Params.from_hash` instead of non-existent `Params.build`. All 187 specs pass.
+- **Content block type/Access** — Translator correctly handles both Hash-inputs and `Canonical::ContentBlock` Data-struct objects with `.type`/`.text` attribute accessors.
+
 ## 0.3.19 - 2026-06-10
 
 ### Fixed

data/Gemfile

@@ -2,13 +2,6 @@
 
 source 'https://rubygems.org'
 
-group :test do
-  llm_base_path = ENV.fetch('LEX_LLM_PATH', File.expand_path('../lex-llm', __dir__))
-  transport_path = ENV.fetch('LEGION_TRANSPORT_PATH', File.expand_path('../../legion-transport', __dir__))
-  gem 'legion-transport', path: transport_path if File.directory?(transport_path)
-  gem 'lex-llm', path: llm_base_path if File.directory?(llm_base_path)
-end
-
 gemspec
 
 group :development do

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.4.3'
+  spec.add_dependency 'lex-llm', '>= 0.5.0'
 end

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

@@ -36,6 +36,13 @@ module Legion
               return unless defined?(Legion::LLM::Discovery)
 
               Legion::LLM::Discovery.refresh_discovered_models!(provider: :bedrock)
+
+              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!
+              end
             rescue StandardError => e
               handle_exception(e, level: :warn, handled: true, operation: 'bedrock.actor.discovery_refresh')
             end

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

@@ -11,6 +11,8 @@ module Legion
   module Extensions
     module Llm
       module Bedrock
+        class StaticCredentialsBlockedError < Legion::Extensions::Llm::ConfigurationError; end
+
         # Amazon Bedrock provider implementation for the Legion::Extensions::Llm contract.
         class Provider < Legion::Extensions::Llm::Provider # rubocop:disable Metrics/ClassLength
           include Legion::Logging::Helper
@@ -18,6 +20,10 @@ module Legion
           STATIC_MODELS = [
             { model: 'anthropic.claude-3-haiku-20240307-v1:0', alias: 'claude-3-haiku' },
             { model: 'anthropic.claude-sonnet-4-20250514-v1:0', alias: 'anthropic.claude-sonnet-4' },
+            { model: 'anthropic.claude-sonnet-4-20250514-v1:0', alias: 'claude-sonnet-4-6' },
+            { model: 'anthropic.claude-sonnet-4-20250514-v1:0', alias: 'claude-sonnet-4-5-20241022' },
+            { model: 'anthropic.claude-opus-4-20250515-v1:0', alias: 'claude-opus-4-8' },
+            { model: 'anthropic.claude-haiku-4-20250506-v1:0', alias: 'claude-haiku-4-5' },
             { model: 'amazon.titan-text-express-v1', alias: 'titan-text-express' },
             { model: 'amazon.titan-embed-text-v2:0', alias: 'titan-embed-text-v2', usage_type: :embedding },
             { model: 'meta.llama3-2-11b-instruct-v1:0', alias: 'llama-3.2-11b-instruct' },
@@ -117,6 +123,10 @@ module Legion
             end
           end
 
+          def translator
+            @translator ||= Translator.new(region: region)
+          end
+
           def api_base
             config.bedrock_endpoint || "https://bedrock-runtime.#{region}.amazonaws.com"
           end
@@ -499,8 +509,15 @@ module Legion
                   state[:raw_events] << { event: event_type, data: raw_event } if dump_path
                   handle_invoke_model_stream_json(raw_event, state, mid) { |chunk| yield chunk if block_given? }
                 end
+              rescue Legion::JSON::ParseError => e
+                handle_exception(e, level: :warn, handled: true,
+                                    operation: 'bedrock.provider.invoke_model_stream.chunk_decode')
               rescue StandardError => e
-                log.warn { "bedrock.provider.invoke_model_stream: chunk decode error=#{sanitize_log(e.message)}" }
+                # Never swallow non-parse errors here — a silent rescue in this
+                # event handler previously hid streaming bugs as dead-air streams.
+                handle_exception(e, level: :error, handled: false,
+                                    operation: 'bedrock.provider.invoke_model_stream.chunk_event')
+                raise
               end
 
               stream.on_error_event do |event|
@@ -555,12 +572,14 @@ module Legion
             Legion::Extensions::Llm::Message.new(**msg_attrs)
           end
 
-          def build_invoke_model_body(messages:, temperature:, max_tokens:, tools:, tool_prefs:, thinking:, **_rest)
+          def build_invoke_model_body(messages:, temperature:, max_tokens:, tools:, tool_prefs:, thinking:, **rest)
+            system_content = extract_invoke_model_system(messages, system: rest[:system])
             body = {
               max_tokens: max_tokens || 4096,
               messages: format_invoke_model_messages(messages),
               anthropic_version: 'bedrock-2023-05-31'
             }
+            body[:system] = system_content if system_content
             body[:temperature] = temperature if temperature
             if tools && !tools.empty?
               tool_format = format_invoke_model_tools(tools, tool_prefs)
@@ -568,11 +587,25 @@ module Legion
               body[:tool_choice] = tool_format[:tool_choice] if tool_format[:tool_choice]
             end
             body[:thinking] = invoke_model_thinking(thinking) if thinking
-            # NOTE: Don't include body[:stream] = true in the JSON body for invoke_model_with_response_stream.
-            # The endpoint itself implies streaming; Bedrock rejects the extra field.
             body
           end
 
+          def extract_invoke_model_system(messages, system: nil)
+            parts = []
+            parts << system.to_s unless system.to_s.empty?
+            messages.each do |msg|
+              role = msg.respond_to?(:role) ? msg.role.to_s : (msg[:role] || msg['role']).to_s
+              next unless role == 'system'
+
+              content = msg.respond_to?(:content) ? msg.content : (msg[:content] || msg['content'])
+              text = content.is_a?(Array) ? content.filter_map { |b| b[:text] || b['text'] }.join("\n") : content.to_s
+              parts << text unless text.empty?
+            end
+            return nil if parts.empty?
+
+            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)
@@ -581,7 +614,7 @@ module Legion
           end
 
           def format_invoke_model_messages(messages)
-            messages.filter_map do |msg|
+            formatted = messages.filter_map do |msg|
               role = msg.respond_to?(:role) ? msg.role.to_s : (msg[:role] || msg['role']).to_s
               next if role == 'system'
 
@@ -598,6 +631,19 @@ module Legion
 
               { role: role == 'tool' ? 'user' : role, content: content }
             end
+            consolidate_adjacent_roles(formatted)
+          end
+
+          def consolidate_adjacent_roles(messages)
+            return messages if messages.size < 2
+
+            messages.each_with_object([]) do |msg, result|
+              if result.last && result.last[:role] == msg[:role]
+                result.last[:content] = Array(result.last[:content]) + Array(msg[:content])
+              else
+                result << msg
+              end
+            end
           end
 
           def format_invoke_model_content(msg)
@@ -664,11 +710,11 @@ module Legion
 
           def format_invoke_model_tools(tools, tool_prefs)
             tool_list = tools.values.map do |tool|
+              raw_schema = tool[:params_schema] || tool['params_schema'] || tool[:parameters] || tool['parameters']
               {
                 name: tool[:name] || tool['name'],
                 description: tool[:description] || tool['description'] || '',
-                input_schema: tool[:params_schema] || tool['params_schema'] ||
-                  { type: 'object', properties: {} }
+                input_schema: Legion::Extensions::Llm::Canonical::ToolDefinition.normalize_parameters(raw_schema)
               }
             end
 
@@ -802,7 +848,11 @@ module Legion
               state[:stop_reason] = delta['stop_reason']
             end
           rescue StandardError => e
-            log.warn { "bedrock.provider.invoke_model_stream_json: error=#{e.message}" }
+            # Re-raise — a swallowed error here turns a streaming bug into a
+            # silent dead-air stream (message_start then nothing).
+            handle_exception(e, level: :error, handled: false,
+                                operation: 'bedrock.provider.invoke_model_stream_json')
+            raise
           end
 
           def static_offerings(**filters)
@@ -816,12 +866,24 @@ module Legion
 
           def offering_from_summary(summary)
             model = value(summary, :model_id)
+            real = real_capabilities_from_summary(summary)
+            policy = Legion::Extensions::Llm::CapabilityPolicy.resolve(
+              real: real,
+              provider_catalog: {},
+              probe: {},
+              provider_envelope: provider_envelope_capabilities,
+              provider_config: provider_capability_config,
+              instance_config: instance_capability_config,
+              model_config: model_capability_config(model)
+            )
+
             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)),
-              capabilities: capabilities_from_summary(summary),
+              capabilities: policy[:capabilities],
+              capability_sources: policy[:sources],
               metadata: normalize_response(summary)
             )
           end
@@ -844,7 +906,7 @@ module Legion
           end
 
           def build_offering(model:, model_family:, usage_type:, instance_id: :default, alias_name: nil,
-                             capabilities: nil, metadata: {})
+                             capabilities: nil, capability_sources: nil, metadata: {})
             limits = infer_limits(model)
             Legion::Extensions::Llm::Routing::ModelOffering.new(
               provider_family: :bedrock,
@@ -854,6 +916,7 @@ module Legion
               model: model,
               usage_type: usage_type,
               capabilities: capabilities || default_capabilities(model),
+              capability_sources: capability_sources,
               limits: limits,
               metadata: metadata.merge(model_family: model_family, alias: alias_name).compact
             )
@@ -903,13 +966,14 @@ module Legion
 
           def format_messages(messages)
             total = messages.size
-            messages.filter_map.with_index do |message, idx|
+            formatted = messages.filter_map.with_index do |message, idx|
               blocks = build_content_blocks(message)
               next if blocks.empty?
 
               cache_blocks = should_cache_message?(idx, total) ? add_cache_control_to_blocks(blocks) : blocks
               { role: bedrock_role(message.role), content: cache_blocks }
             end
+            consolidate_adjacent_roles(formatted)
           end
 
           def tool_result_blocks(message)
@@ -967,7 +1031,9 @@ module Legion
             text = content_text(message.content)
             blocks << { text: text } if text && !text.strip.empty?
 
-            message.tool_calls.each_value do |call|
+            # Array is canonical (name-keyed hashes dropped parallel same-name calls)
+            calls = message.tool_calls.is_a?(Hash) ? message.tool_calls.values : Array(message.tool_calls)
+            calls.each do |call|
               blocks << {
                 tool_use: {
                   tool_use_id: call.id,
@@ -1062,9 +1128,12 @@ module Legion
           end
 
           def tool_schema(tool)
-            return tool.params_schema if tool.respond_to?(:params_schema) && tool.params_schema
-
-            { type: 'object', properties: {} }
+            raw = if tool.respond_to?(:params_schema) && tool.params_schema
+                    tool.params_schema
+                  elsif tool.respond_to?(:parameters)
+                    tool.parameters
+                  end
+            Legion::Extensions::Llm::Canonical::ToolDefinition.normalize_parameters(raw)
           end
 
           def tool_choice(tool_prefs)
@@ -1273,8 +1342,8 @@ module Legion
               # Bedrock streaming: text blocks use delta.text,
               # reasoning/thinking blocks use delta.reasoning.text or delta.thinking.text
               text = value(delta, :text) ||
-                     (value(delta, :reasoning) ? value(reasoning_delta, :text) : nil) ||
-                     (value(delta, :thinking) ? value(thinking_delta, :text) : nil)
+                     value(value(delta, :reasoning), :text) ||
+                     value(value(delta, :thinking), :text)
               if text
                 if state[:in_thinking]
                   state[:thinking] << text
@@ -1399,7 +1468,7 @@ module Legion
             return nil unless config.bedrock_access_key_id
 
             if static_credentials_blocked?
-              raise SecurityError,
+              raise StaticCredentialsBlockedError,
                     'Static AWS credentials are disabled (security.block_static_aws_credentials=true); use IAM roles'
             end
             log.warn('[bedrock] Using static AWS credentials — prefer IAM roles for production')
@@ -1467,6 +1536,59 @@ module Legion
             caps
           end
 
+          def real_capabilities_from_summary(summary)
+            caps = {}
+            caps[:streaming] = true if value(summary, :response_streaming_supported)
+            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
+          end
+
+          def provider_envelope_capabilities
+            # Bedrock Converse API supports tool use across all active chat model families
+            { 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