lex-llm-bedrock 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3d55da87620e9773b25877502156b297f7acbbd1bdc08cf18fa61f5edb0c57e
-  data.tar.gz: 04d20d2e3347e52f52c165fb629e9b1cd6a56eb9f20a2f7b348c4c4e299a67cc
+  metadata.gz: 40cc613c728c144f3ec60b45334ea9bea2a1ef6670d61ce57987acad05da6186
+  data.tar.gz: 88a4dde57a0c352d73645ca6aff5396732aafbf032d0c366daad2237d669e8d0
 SHA512:
-  metadata.gz: 763493247d7a76a313e82236d40aad82893dee8ca8d91b579da49dfe9f378dc16189566877aa3d7d45bb3c77e0a3d60e4a3296405527db8b86989844a1ae0b2a
-  data.tar.gz: 60e48404047623d27afee51f41c00584e51fbdd36478f71cfad5e7da19b10b486d3a2fe521c2e0396486e863e9a2942ea5abf0f68cb3346ede65fadc4aa86d6b
+  metadata.gz: befa988b2d8d123a63c70f763ac86d6a46c0c2fb2b5b710241ae4c97d712cca706dfc37ae1fc13b35bbe5ac5501ac8fbd107ebe4fd9a73717d06874dd6e1100c
+  data.tar.gz: aae183ccc0799a267fb09d339765656f94250e2ee9527504f00cc0a3eb28318f0e771d215876b4b3a9500a0d5c40019d01f8e610dd183b6e6c2b8e275c98c2ef

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.1.3 - 2026-04-28
+
+- Remove the unused runtime `legion/settings` require while preserving the gemspec dependency.
+
+## 0.1.2 - 2026-04-28
+
+- Publish best-effort `llm.registry` live readiness and live foundation-model availability events using `lex-llm` registry envelopes when transport is already available.
+
 ## 0.1.1 - 2026-04-28
 
 - Require `lex-llm >= 0.1.5` for the shared model offering, alias, readiness, and fleet lane contract used by Bedrock routing metadata.

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

@@ -4,7 +4,6 @@ require 'aws-sdk-bedrock'
 require 'aws-sdk-bedrockruntime'
 require 'legion/json'
 require 'legion/logging'
-require 'legion/settings'
 require 'legion/extensions/llm'
 
 module Legion
@@ -26,6 +25,8 @@ 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
@@ -43,6 +44,10 @@ module Legion
             def configuration_requirements = []
             def capabilities = Capabilities
 
+            def registry_publisher
+              @registry_publisher ||= RegistryPublisher.new
+            end
+
             def resolve_model_id(model_id, config: nil) # rubocop:disable Lint/UnusedMethodArgument
               ALIASES.fetch(model_id.to_s, model_id.to_s)
             end
@@ -83,7 +88,9 @@ module Legion
             return static_offerings(**filters) unless live
 
             response = bedrock_client.list_foundation_models(**filters)
-            Array(value(response, :model_summaries)).map { |summary| offering_from_summary(summary) }
+            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))
+            end
           end
 
           def offering_for(model:, model_family: nil, instance_id: :default, **metadata)
@@ -116,7 +123,10 @@ module Legion
           end
 
           def readiness(live: false)
-            health(live: live).merge(local: false, remote: true, api_base: api_base, endpoints: endpoint_manifest)
+            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
+            end
           end
 
           def list_models

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

@@ -0,0 +1,93 @@
+# 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

@@ -0,0 +1,100 @@
+# 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

@@ -0,0 +1,24 @@
+# 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

@@ -0,0 +1,42 @@
+# 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

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module Bedrock
-        VERSION = '0.1.1'
+        VERSION = '0.1.3'
       end
     end
   end

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

@@ -2,6 +2,8 @@
 
 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

metadata

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