lex-llm-bedrock 0.4.0 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0c19835470c757fe2f6ea3a1708884b0145694e921e34b22fca0b89c8aac69b
-  data.tar.gz: b0fe049d5182e0760f5740e42fc7488eb80239aabba7a753e34d486d915e3c2d
+  metadata.gz: 05badbea355fec879dbd270070928472682c35d8709e3e6336e0080ca00aeb36
+  data.tar.gz: ec34813a7de565ad347c95777715054d27bd53ce71b04d8ddfd57de149852c9e
 SHA512:
-  metadata.gz: 23604b77e5b16449e74d08a5fe14e9ee9a0e0bbb3ed164103e42f3005d7c483f3b65ea58d976701429a33632f89269757e1e2e33cf1f0289d04c8a1f231c325f
-  data.tar.gz: 6b6f898e45dfc824daa1d3ca96381af08b40e7ed72b1fd90f57d378285db0cdecc1ee90ebbeb227c52d4494bbfc7be4b5752e8cbdd1b9bb616019cec09f2db02
+  metadata.gz: '073218f79b092a425703aa62f45b8d07d69afcf01d1249b66435fa4dce7211f74cbfab184e7df61f506f92c0ca4322d1d8448e6317ed5d52870d699ff42757e9'
+  data.tar.gz: 415524d66dcb863b18036935b15b7965996adb249d78779845b6f53679e22745b9316a438de386e490051cf7c46af6bc3264cf3db24d2b7517a7c5c4d49c9375

data/CHANGELOG.md

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

data/Gemfile

@@ -4,15 +4,6 @@ source 'https://rubygems.org'
 
 gemspec
 
-group :test do
-  transport_path = ENV.fetch('LEGION_TRANSPORT_PATH', File.expand_path('../../legion-transport', __dir__))
-  gem 'legion-transport', path: transport_path if File.directory?(transport_path)
-end
-
-# lex-llm (>= 0.5.0) comes from gemspec with canonical types + conformance kit.
-# Override with a path/branch reference for local development only:
-#   gem 'lex-llm', path: ENV.fetch('LEX_LLM_PATH', '../lex-llm')
-
 group :development do
   gem 'bundler', '>= 2.0'
   gem 'rake', '>= 13.0'

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

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

@@ -205,7 +205,7 @@ module Legion
                 tool_spec: {
                   name: tool.name,
                   description: tool.description.to_s,
-                  input_schema: { json: tool.parameters || { type: 'object', properties: {} } }
+                  input_schema: { json: tool.parameters }
                 }
               }
             end
@@ -234,6 +234,9 @@ module Legion
               anthropic_version: 'bedrock-2023-05-31'
             }
 
+            sys = render_invoke_system(canonical)
+            body[:system] = sys if sys
+
             temp = canonical.params&.temperature
             body[:temperature] = temp if temp
 
@@ -256,6 +259,22 @@ module Legion
             { type: 'enabled', budget_tokens: budget }
           end
 
+          def render_invoke_system(canonical)
+            sys = canonical.system
+            return nil if sys.nil? || sys.to_s.strip.empty?
+
+            if sys.is_a?(Array)
+              sys.map do |block|
+                wire = { type: 'text', text: (block[:text] || block['text'] || block.to_s).to_s }
+                cc = block[:cache_control] || block['cache_control']
+                wire[:cache_control] = cc if cc
+                wire
+              end
+            else
+              [{ type: 'text', text: sys.to_s }]
+            end
+          end
+
           def build_invoke_tools(canonical)
             return nil unless canonical.tools && !canonical.tools.empty?
 
@@ -263,7 +282,7 @@ module Legion
               {
                 name: tool.name,
                 description: (tool.description || '').to_s,
-                input_schema: tool.parameters || { type: 'object', properties: {} }
+                input_schema: tool.parameters
               }
             end
 

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

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

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

@@ -5,6 +5,7 @@ require 'legion/extensions/llm/bedrock/provider'
 require 'legion/extensions/llm/bedrock/translator'
 require 'legion/extensions/llm/bedrock/version'
 require 'legion/logging/helper'
+require_relative 'bedrock/actors/discovery_refresh'
 
 module Legion
   module Extensions
@@ -44,10 +45,7 @@ module Legion
               fleet: {
                 enabled: false,
                 respond_to_requests: false,
-                capabilities: %i[chat stream_chat embed],
-                lanes: [],
-                concurrency: 4,
-                queue_suffix: nil
+                capabilities: %i[chat stream_chat embed tools]
               }
             }
           )
@@ -223,8 +221,7 @@ module Legion
           config.except(:api_key)
         end
 
-        Legion::Extensions::Llm::Configuration.register_provider_options(Provider.configuration_options) if
-          Legion::Extensions::Llm::Configuration.respond_to?(:register_provider_options)
+        Legion::Extensions::Llm::Configuration.register_provider_options(Provider.configuration_options)
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-bedrock
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.3
 platform: ruby
 authors:
 - LegionIO