lex-llm-bedrock 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e65f38c28a0411727577216ea5bc01057520cd14e110fdb88d02da6248125aad
-  data.tar.gz: d93dfe83c8e3acf0944518c1e964ddcccda59301a6a83460bff4618a883f34d8
+  metadata.gz: eafb04fa29d1bf032323c4040c7cdbe0ea2d3cf1c72328864ec54b5e2f7ce117
+  data.tar.gz: 6da27c531876ff32af29b783548b86bed7a4146f45f0b94da679320dd594310b
 SHA512:
-  metadata.gz: 772d8484c70e24d732e74d751fed2264c253cdbc245d91d39c5aa0e642f0c3828fe144da025fd5237c33e694bb8ab7e9fa5dd009092ea40e75009eca34250b53
-  data.tar.gz: a00538ee0875ea03b3c25b163eecf791107b6a8ed8ec48a705b9cb9a0f7af32a4abcc5c1c968031eb43b736249acfe55bfefe08f6b8647a5476b775c67318336
+  metadata.gz: 7b7a1bc938f269380f0310cfd0e4a2f3561e986ed09db904dbe6a31663451658bac03e56b54c57f3c32efd85c7d83eb64e8d50fdbeac20efe2314f6a9e5d0a38
+  data.tar.gz: db293ebc885b48aa2902ecccfd5cf8e47bf58fd775ec211d31cb9a491dcecb60c5146989175affd2e1c59bd3f2429492eea94f36d202f41955708d72a3ec5780

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 0.2.0 - 2026-04-30
+
+- Adopt lex-llm 0.1.9 base contract: flat `default_settings`, base `RegistryPublisher`, base `RegistryEventBuilder`.
+- Replace `provider_settings` call with flat default_settings hash (default_model, region, credentials, whitelist/blacklist, TLS, instances).
+- Remove `Provider.register` call; register configuration options directly via `Configuration.register_provider_options`.
+- Delete local `RegistryPublisher`, `RegistryEventBuilder`, and `transport/` directory; use parameterized base classes from lex-llm.
+- Move `registry_publisher` from `Provider` class method to `Bedrock` module method using `Legion::Extensions::Llm::RegistryPublisher.new(provider_family: :bedrock)`.
+- Rewrite `list_models` to return `Model::Info` with `capabilities`, `modalities_input`, and `modalities_output` derived from Bedrock `inputModalities`/`outputModalities`.
+- Publish discovered models via `publish_models_async` (base contract) instead of `publish_offerings_async`.
+- Bump gemspec dependency to `lex-llm >= 0.1.9`.
+
+## 0.1.5 - 2026-04-30
+
+- Audit logging, rescue blocks, and README for full observability.
+- Add `include Legion::Logging::Helper` to Provider, RegistryPublisher, and RegistryEventBuilder.
+- Replace all bare rescue blocks with `handle_exception(e, level:, handled:, operation:)` calls.
+- Add `log.info` for key actions: chat, stream, embed, health, discovery, list_models.
+- Remove custom `log_publish_failure` method in favor of standard `handle_exception`.
+- Update README with architecture, file map, dependency table, and development guide.
+
 ## 0.1.4 - 2026-04-30
 
 - Add headers: parameter to complete method signature matching base provider contract

data/README.md

@@ -4,6 +4,48 @@ Amazon Bedrock provider extension for `Legion::Extensions::Llm`.
 
 This gem adds a hosted Bedrock provider surface for Legion LLM routing without depending on the old `legion-llm` gem. It uses the official AWS SDK for Ruby and keeps discovery offline by default, so loading the extension or running tests does not require live AWS credentials. It requires `lex-llm >= 0.1.5` for the shared model offering, alias, readiness, and fleet lane contract.
 
+## Architecture
+
+```
+Legion::Extensions::Llm::Bedrock
+├── Provider               # Bedrock implementation of the lex-llm Provider contract
+│   ├── Capabilities       # Capability predicates inferred from model IDs
+│   ├── chat / stream      # Converse / ConverseStream API calls
+│   ├── embed              # Titan InvokeModel embedding
+│   ├── count_tokens       # CountTokens API call
+│   ├── discover_offerings # Static catalog + live ListFoundationModels
+│   ├── health / readiness # Provider health checks with live AWS verification
+│   └── list_models        # Live model enumeration
+├── RegistryEventBuilder   # Builds sanitized lex-llm registry envelopes
+├── RegistryPublisher      # Best-effort async publisher for registry events
+└── Transport
+    ├── Exchanges::LlmRegistry    # Topic exchange for llm.registry events
+    └── Messages::RegistryEvent   # AMQP message for registry event publishing
+```
+
+## Dependencies
+
+| Gem | Required | Purpose |
+|-----|----------|---------|
+| `aws-sdk-bedrock` | Yes | Bedrock management client (ListFoundationModels) |
+| `aws-sdk-bedrockruntime` | Yes | Bedrock runtime client (Converse, InvokeModel) |
+| `legion-json` (>= 1.2.1) | Yes | JSON serialization |
+| `legion-logging` (>= 1.3.2) | Yes | Structured logging via Helper |
+| `legion-settings` (>= 1.3.14) | Yes | Configuration |
+| `lex-llm` (>= 0.1.5) | Yes | Shared provider contract, model offerings, routing |
+
+## File Map
+
+| Path | Purpose |
+|------|---------|
+| `lib/legion/extensions/llm/bedrock.rb` | Entry point: namespace, default settings, provider registration |
+| `lib/legion/extensions/llm/bedrock/provider.rb` | Full Bedrock provider implementation |
+| `lib/legion/extensions/llm/bedrock/registry_event_builder.rb` | Builds lex-llm registry event envelopes |
+| `lib/legion/extensions/llm/bedrock/registry_publisher.rb` | Best-effort async registry event publishing |
+| `lib/legion/extensions/llm/bedrock/transport/exchanges/llm_registry.rb` | AMQP topic exchange definition |
+| `lib/legion/extensions/llm/bedrock/transport/messages/registry_event.rb` | AMQP message class for registry events |
+| `lib/legion/extensions/llm/bedrock/version.rb` | `VERSION` constant |
+
 ## Install
 
 ```ruby
@@ -31,6 +73,8 @@ If explicit keys are not configured, the AWS SDK default credential provider cha
 Legion::Extensions::Llm::Bedrock.default_settings
 ```
 
+Configuration options: `bedrock_region`, `bedrock_endpoint`, `bedrock_access_key_id`, `bedrock_secret_access_key`, `bedrock_session_token`, `bedrock_profile`, `bedrock_stub_responses`.
+
 ## Provider Surface
 
 ```ruby
@@ -58,6 +102,8 @@ Every offering uses:
 
 Known aliases are intentionally small and conservative. For example, `claude-3-haiku` resolves to `anthropic.claude-3-haiku-20240307-v1:0`, while the preserved Bedrock model ID remains the routing model.
 
+Static models: `claude-3-haiku`, `titan-text-express`, `titan-embed-text-v2`, `llama-3.2-11b-instruct`, `mistral-large-3`.
+
 ## API Contract
 
 The implementation is intentionally limited to Bedrock operations documented by AWS:
@@ -70,10 +116,31 @@ The implementation is intentionally limited to Bedrock operations documented by
 
 Provider-specific request bodies are not guessed. Non-Titan embedding models raise until their documented body shape is added explicitly.
 
-AWS references:
+## Observability
+
+All classes include `Legion::Logging::Helper` for structured logging:
+
+- **Info-level**: provider connections, API calls (chat, stream, embed), model listing, health checks
+- **Debug-level**: offline health checks, readiness probes, token counting, registry event scheduling
+- **Rescue blocks**: every rescue calls `handle_exception(e, level:, handled:, operation:)` with dot-separated operation names (e.g., `bedrock.provider.health`, `bedrock.registry_publisher.publish_event`)
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec --format progress  # all pass
+bundle exec rubocop -A               # auto-fix
+bundle exec rubocop                  # lint check (0 offenses expected)
+```
+
+## AWS References
 
 - [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html)
 - [ConverseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStream.html)
 - [CountTokens](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_CountTokens.html)
 - [ListFoundationModels](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_ListFoundationModels.html)
 - [Foundation model information](https://docs.aws.amazon.com/bedrock/latest/userguide/foundation-models-reference.html)
+
+## License
+
+MIT

data/lex-llm-bedrock.gemspec

@@ -28,5 +28,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'legion-json', '>= 1.2.1'
   spec.add_dependency 'legion-logging', '>= 1.3.2'
   spec.add_dependency 'legion-settings', '>= 1.3.14'
-  spec.add_dependency 'lex-llm', '>= 0.1.5'
+  spec.add_dependency 'lex-llm', '>= 0.2.0'
 end

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

@@ -12,6 +12,8 @@ module Legion
       module Bedrock
         # Amazon Bedrock provider implementation for the Legion::Extensions::Llm contract.
         class Provider < Legion::Extensions::Llm::Provider # rubocop:disable Metrics/ClassLength
+          include Legion::Logging::Helper
+
           DEFAULT_REGION = 'us-east-1'
 
           STATIC_MODELS = [
@@ -25,8 +27,6 @@ module Legion
           ALIASES = STATIC_MODELS.to_h { |entry| [entry.fetch(:alias), entry.fetch(:model)] }.freeze
 
           class << self
-            attr_writer :registry_publisher
-
             def slug = 'bedrock'
 
             def configuration_options
@@ -45,7 +45,7 @@ module Legion
             def capabilities = Capabilities
 
             def registry_publisher
-              @registry_publisher ||= RegistryPublisher.new
+              Bedrock.registry_publisher
             end
 
             def resolve_model_id(model_id, config: nil) # rubocop:disable Lint/UnusedMethodArgument
@@ -85,11 +85,15 @@ module Legion
           end
 
           def discover_offerings(live: false, **filters)
-            return static_offerings(**filters) unless live
+            unless live
+              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)
             Array(value(response, :model_summaries)).map { |summary| offering_from_summary(summary) }.tap do |offerings|
-              self.class.registry_publisher.publish_offerings_async(offerings, readiness: readiness(live: false))
+              log.info { "bedrock.provider.discover_offerings: found #{offerings.size} models" }
             end
           end
 
@@ -114,15 +118,22 @@ module Legion
               live: live,
               credentials: credential_source
             }
-            return baseline.merge(checked: false) unless live
+            unless live
+              log.debug { "bedrock.provider.health: offline check (region=#{region})" }
+              return baseline.merge(checked: false)
+            end
 
+            log.info { "bedrock.provider.health: live check (region=#{region})" }
             bedrock_client.list_foundation_models
+            log.info { 'bedrock.provider.health: live check passed' }
             baseline.merge(checked: true)
           rescue StandardError => e
+            handle_exception(e, level: :warn, handled: true, operation: 'bedrock.provider.health')
             baseline.merge(checked: true, ready: false, error: e.class.name, message: e.message)
           end
 
           def readiness(live: false)
+            log.debug { "bedrock.provider.readiness: checking (live=#{live})" }
             health(live: live).merge(local: false, remote: true, api_base: api_base,
                                      endpoints: endpoint_manifest).tap do |metadata|
               self.class.registry_publisher.publish_readiness_async(metadata) if live
@@ -130,19 +141,16 @@ module Legion
           end
 
           def list_models
-            discover_offerings(live: true).map do |offering|
-              Legion::Extensions::Llm::Model::Info.new(
-                id: offering.model,
-                name: offering.metadata[:alias] || offering.model,
-                provider: :bedrock,
-                family: offering.metadata[:model_family],
-                capabilities: offering.capabilities.map(&:to_s),
-                metadata: offering.to_h
-              )
-            end
+            log.info { 'bedrock.provider.list_models: fetching live model list' }
+            response = bedrock_client.list_foundation_models
+            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 chat(messages, model:, temperature: nil, max_tokens: nil, tools: {}, tool_prefs: nil, params: {})
+            log.info { "bedrock.provider.chat: model=#{model_id(model)} messages=#{messages.size}" }
             request = Utils.deep_merge(
               converse_request(messages, model:, temperature:, max_tokens:, tools:, tool_prefs:),
               params
@@ -152,6 +160,7 @@ module Legion
 
           def stream(messages, model:, temperature: nil, max_tokens: nil, tools: {}, tool_prefs: nil, params: {},
                      &)
+            log.info { "bedrock.provider.stream: model=#{model_id(model)} messages=#{messages.size}" }
             request = Utils.deep_merge(
               converse_request(messages, model:, temperature:, max_tokens:, tools:, tool_prefs:),
               params
@@ -160,6 +169,7 @@ module Legion
           end
 
           def count_tokens(messages, model:, system: nil, params: {})
+            log.debug { "bedrock.provider.count_tokens: model=#{model_id(model)}" }
             request = Utils.deep_merge(
               {
                 model_id: model_id(model),
@@ -172,20 +182,21 @@ module Legion
           end
 
           def embed(text, model:, dimensions: nil)
-            model_id = model_id(model)
-            unless titan_embed?(model_id)
+            mid = model_id(model)
+            unless titan_embed?(mid)
               raise NotImplementedError,
-                    "Bedrock embedding payload for #{model_id} is not standardized"
+                    "Bedrock embedding payload for #{mid} is not standardized"
             end
 
+            log.info { "bedrock.provider.embed: model=#{mid}" }
             body = { inputText: text, dimensions: dimensions }.compact
             response = runtime_client.invoke_model(
-              model_id: model_id,
+              model_id: mid,
               content_type: 'application/json',
               accept: 'application/json',
               body: Legion::JSON.generate(body)
             )
-            parse_embedding_response(response, model: model_id)
+            parse_embedding_response(response, model: mid)
           end
 
           def complete(messages, tools:, temperature:, model:, params: {}, headers: {}, schema: nil, thinking: nil, # rubocop:disable Lint/UnusedMethodArgument
@@ -225,6 +236,23 @@ module Legion
             )
           end
 
+          def model_info_from_summary(summary)
+            model = value(summary, :model_id)
+            input_mods = Array(value(summary, :input_modalities)).map { |m| m.to_s.downcase }
+            output_mods = Array(value(summary, :output_modalities)).map { |m| m.to_s.downcase }
+
+            Legion::Extensions::Llm::Model::Info.new(
+              id: model,
+              name: alias_for(model) || model,
+              provider: :bedrock,
+              family: (normalize_provider(value(summary, :provider_name)) || model_family_for(model)).to_s,
+              capabilities: capabilities_from_modalities(input_mods, output_mods, summary),
+              modalities_input: input_mods,
+              modalities_output: output_mods,
+              metadata: normalize_response(summary)
+            )
+          end
+
           def build_offering(model:, model_family:, usage_type:, instance_id: :default, alias_name: nil,
                              capabilities: nil, metadata: {})
             Legion::Extensions::Llm::Routing::ModelOffering.new(
@@ -461,6 +489,18 @@ module Legion
             capabilities
           end
 
+          def capabilities_from_modalities(input_mods, output_mods, summary)
+            caps = []
+            caps << :embedding if output_mods.include?('embedding')
+            unless caps.include?(:embedding)
+              caps << :completion
+              caps << :streaming if value(summary, :response_streaming_supported)
+            end
+            caps << :vision if input_mods.include?('image')
+            caps << :tools if caps.include?(:completion)
+            caps
+          end
+
           def model_family_for(model)
             normalize_provider(model.to_s.split('.').first)
           end

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module Bedrock
-        VERSION = '0.1.4'
+        VERSION = '0.2.0'
       end
     end
   end

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

@@ -2,8 +2,6 @@
 
 require 'legion/extensions/llm'
 require 'legion/extensions/llm/bedrock/provider'
-require 'legion/extensions/llm/bedrock/registry_event_builder'
-require 'legion/extensions/llm/bedrock/registry_publisher'
 require 'legion/extensions/llm/bedrock/version'
 
 module Legion
@@ -16,34 +14,34 @@ module Legion
         PROVIDER_FAMILY = :bedrock
 
         def self.default_settings
-          ::Legion::Extensions::Llm.provider_settings(
-            family: PROVIDER_FAMILY,
-            discovery: { enabled: false, live: false, regions: %w[us-east-1 us-west-2] },
-            instance: {
-              endpoint: 'https://bedrock-runtime.us-east-1.amazonaws.com',
-              region: 'us-east-1',
-              tier: :frontier,
-              transport: :aws_sdk,
-              credentials: {
-                provider: 'aws-sdk-default-chain',
-                access_key_id: 'env://AWS_ACCESS_KEY_ID',
-                secret_access_key: 'env://AWS_SECRET_ACCESS_KEY',
-                session_token: 'env://AWS_SESSION_TOKEN',
-                profile: 'env://AWS_PROFILE'
-              },
-              usage: { inference: true, embedding: true, token_counting: true },
-              limits: { concurrency: 4 }
-            }
-          )
+          {
+            enabled: false,
+            default_model: 'us.anthropic.claude-sonnet-4-6',
+            region: 'us-east-2',
+            bearer_token: nil,
+            api_key: nil,
+            secret_key: nil,
+            session_token: nil,
+            model_whitelist: [],
+            model_blacklist: [],
+            model_cache_ttl: 3600,
+            tls: { enabled: false, verify: :peer },
+            instances: {}
+          }
         end
 
         def self.provider_class
           Provider
         end
+
+        def self.registry_publisher
+          @registry_publisher ||= Legion::Extensions::Llm::RegistryPublisher.new(provider_family: PROVIDER_FAMILY)
+        end
       end
     end
   end
 end
 
-Legion::Extensions::Llm::Provider.register(Legion::Extensions::Llm::Bedrock::PROVIDER_FAMILY,
-                                           Legion::Extensions::Llm::Bedrock::Provider)
+Legion::Extensions::Llm::Configuration.register_provider_options(
+  Legion::Extensions::Llm::Bedrock::Provider.configuration_options
+)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-bedrock
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - LegionIO
@@ -85,14 +85,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.5
+        version: 0.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.5
+        version: 0.2.0
 description: Amazon Bedrock provider integration for the LegionIO LLM routing framework.
 email:
 - matthewdiverson@gmail.com
@@ -112,10 +112,6 @@ files:
 - lex-llm-bedrock.gemspec
 - lib/legion/extensions/llm/bedrock.rb
 - lib/legion/extensions/llm/bedrock/provider.rb
-- lib/legion/extensions/llm/bedrock/registry_event_builder.rb
-- lib/legion/extensions/llm/bedrock/registry_publisher.rb
-- lib/legion/extensions/llm/bedrock/transport/exchanges/llm_registry.rb
-- lib/legion/extensions/llm/bedrock/transport/messages/registry_event.rb
 - lib/legion/extensions/llm/bedrock/version.rb
 homepage: https://github.com/LegionIO/lex-llm-bedrock
 licenses:

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

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Extensions
-    module Llm
-      module Bedrock
-        # Builds sanitized lex-llm registry envelopes for Bedrock provider state.
-        class RegistryEventBuilder
-          def readiness(readiness)
-            registry_event_class.public_send(
-              readiness[:ready] ? :available : :unavailable,
-              provider_offering(readiness),
-              runtime: runtime_metadata,
-              health: readiness_health(readiness),
-              metadata: readiness_metadata(readiness)
-            )
-          end
-
-          def offering_available(offering, readiness:)
-            registry_event_class.available(
-              offering,
-              runtime: runtime_metadata,
-              health: offering_health(readiness),
-              metadata: offering_metadata
-            )
-          end
-
-          private
-
-          def provider_offering(readiness)
-            {
-              provider_family: :bedrock,
-              provider_instance: provider_instance,
-              transport: :aws_sdk,
-              model: 'provider-readiness',
-              usage_type: :inference,
-              capabilities: [],
-              health: readiness_health(readiness),
-              metadata: { lex: :llm_bedrock, provider_readiness: true }
-            }
-          end
-
-          def readiness_health(readiness)
-            health = {
-              ready: readiness[:ready] == true,
-              status: readiness[:ready] ? :available : :unavailable,
-              checked: readiness[:checked] != false
-            }
-            add_readiness_error(health, readiness)
-          end
-
-          def add_readiness_error(health, source)
-            error_class = source[:error] || source['error']
-            error_message = source[:message] || source['message']
-            health[:error_class] = error_class if error_class
-            health[:error] = error_message if error_message
-            health
-          end
-
-          def offering_health(readiness)
-            ready = readiness.fetch(:ready, true) == true
-            { ready:, status: ready ? :available : :degraded, checked: readiness[:checked] != false }
-          end
-
-          def readiness_metadata(readiness)
-            {
-              extension: :lex_llm_bedrock,
-              provider: :bedrock,
-              configured: readiness[:configured] == true,
-              live: readiness[:live] == true
-            }
-          end
-
-          def offering_metadata
-            { extension: :lex_llm_bedrock, provider: :bedrock }
-          end
-
-          def runtime_metadata
-            { node: provider_instance }
-          end
-
-          def provider_instance
-            :bedrock
-          end
-
-          def registry_event_class
-            ::Legion::Extensions::Llm::Routing::RegistryEvent
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Extensions
-    module Llm
-      module Bedrock
-        # Best-effort publisher for Bedrock provider availability events.
-        class RegistryPublisher
-          APP_ID = 'lex-llm-bedrock'
-
-          def initialize(builder: RegistryEventBuilder.new)
-            @builder = builder
-          end
-
-          def publish_readiness_async(readiness)
-            schedule { publish_event(@builder.readiness(readiness)) }
-          end
-
-          def publish_offerings_async(offerings, readiness:)
-            schedule do
-              Array(offerings).each do |offering|
-                publish_event(@builder.offering_available(offering, readiness:))
-              end
-            end
-          end
-
-          private
-
-          def schedule(&)
-            return false unless publishing_available?
-
-            Thread.new do
-              Thread.current.abort_on_exception = false
-              yield
-            rescue StandardError => e
-              log_publish_failure(e, level: :debug)
-            end
-          rescue StandardError => e
-            log_publish_failure(e, level: :debug)
-            false
-          end
-
-          def publish_event(event)
-            return false unless publishing_available?
-
-            message_class.new(event:, app_id: APP_ID).publish(spool: false)
-          rescue StandardError => e
-            log_publish_failure(e)
-            false
-          end
-
-          def publishing_available?
-            return false unless registry_event_available?
-            return false unless transport_message_available?
-            return true unless defined?(::Legion::Transport::Connection)
-            return true unless ::Legion::Transport::Connection.respond_to?(:session_open?)
-
-            ::Legion::Transport::Connection.session_open?
-          rescue StandardError
-            false
-          end
-
-          def registry_event_available?
-            defined?(::Legion::Extensions::Llm::Routing::RegistryEvent)
-          end
-
-          def transport_message_available?
-            return true if message_class_defined?
-            return false unless defined?(::Legion::Transport::Message) && defined?(::Legion::Transport::Exchange)
-
-            require 'legion/extensions/llm/bedrock/transport/messages/registry_event'
-            message_class_defined?
-          rescue LoadError
-            false
-          end
-
-          def message_class_defined?
-            defined?(::Legion::Extensions::Llm::Bedrock::Transport::Messages::RegistryEvent)
-          end
-
-          def message_class
-            ::Legion::Extensions::Llm::Bedrock::Transport::Messages::RegistryEvent
-          end
-
-          def log_publish_failure(error, level: :warn)
-            message = "[lex-llm-bedrock] llm.registry publish failed: #{error.class}: #{error.message}"
-            logger = ::Legion::Extensions::Llm.logger if defined?(::Legion::Extensions::Llm)
-            if logger.respond_to?(level)
-              logger.public_send(level, message)
-            elsif logger.respond_to?(:debug)
-              logger.debug(message)
-            end
-          rescue StandardError
-            nil
-          end
-        end
-      end
-    end
-  end
-end

data/lib/legion/extensions/llm/bedrock/transport/exchanges/llm_registry.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Extensions
-    module Llm
-      module Bedrock
-        module Transport
-          module Exchanges
-            # Topic exchange for Bedrock provider availability events.
-            class LlmRegistry < ::Legion::Transport::Exchange
-              def exchange_name
-                'llm.registry'
-              end
-
-              def default_type
-                'topic'
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/legion/extensions/llm/bedrock/transport/messages/registry_event.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require 'legion/extensions/llm/bedrock/transport/exchanges/llm_registry'
-
-module Legion
-  module Extensions
-    module Llm
-      module Bedrock
-        module Transport
-          module Messages
-            # Publishes lex-llm RegistryEvent envelopes to the llm.registry exchange.
-            class RegistryEvent < ::Legion::Transport::Message
-              def initialize(event:, **options)
-                super(**event.to_h.merge(options))
-              end
-
-              def exchange
-                Transport::Exchanges::LlmRegistry
-              end
-
-              def routing_key
-                @options[:routing_key] || "llm.registry.#{@options.fetch(:event_type)}"
-              end
-
-              def type
-                'llm.registry.event'
-              end
-
-              def app_id
-                @options[:app_id] || RegistryPublisher::APP_ID
-              end
-
-              def persistent # rubocop:disable Naming/PredicateMethod
-                false
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end