lex-llm-azure-foundry 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33f564df8dc0e10567cb8780f15976c66d399ca545a6303674bd67e11896e404
-  data.tar.gz: bd35a164c1adb9c8c1ed3eaa590dc97908b2c2bfca74d09e2784ae41349d0c24
+  metadata.gz: a4c8f175645147e84ce67e151aa2ef886ca23a96f0d00f37f27e90549ea7d9c4
+  data.tar.gz: d969e077a6ac3e06ed51dd51b10a83ea7574dfe5495438c3735413def6709dd6
 SHA512:
-  metadata.gz: 861eb2e467c3ef97123dd06705cd5eccbfb708573231e85cc171a10a8b7749bca5001cbe92e34eb5a8fb5a0a275277350f245a45daeba38b3efd843d8ae5c65b
-  data.tar.gz: a78aaace8611a9f72beb67f524d7e6c949f7c737698d77770280ab9d8bbee4305720ebed779d65e3df26971eb2ad2c8a457bd3b9640e5dc905e83b8a8136b593
+  metadata.gz: 20122b9eafaa1c5f1240c041ed6f657e95f6909d80e67ee06b133f1adaa0fd1d0816ce000a155590052134fba4139056ab905024e844d8aa6ad7cdcbcd09fdd6
+  data.tar.gz: b9e84ee384e6ad871eee3baf65d29ebdeea9c18a874c07f9776874b97b76138c55fccaab82d76787cd123a84c2840aa80f95c1b81861534190ea7d4e2cf5411f

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.1.2 - 2026-04-28
+
+- Publish best-effort `llm.registry` live readiness and configured deployment 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, canonical alias, readiness, and fleet lane contract used by Azure deployment routing metadata.
+
 ## 0.1.0 - 2026-04-28
 
 - Initial Legion LLM Azure AI Foundry provider extension scaffold.

data/README.md

@@ -2,7 +2,7 @@
 
 LegionIO LLM provider extension for Azure AI Foundry Models and Azure OpenAI hosted deployments.
 
-This gem lives under `Legion::Extensions::Llm::AzureFoundry` and depends on `lex-llm` for shared provider-neutral routing, fleet, model-offering, and schema primitives.
+This gem lives under `Legion::Extensions::Llm::AzureFoundry` and depends on `lex-llm >= 0.1.5` for shared provider-neutral routing, fleet, model-offering, readiness, canonical-alias, and schema primitives.
 
 Load it with `require 'legion/extensions/llm/azure_foundry'`.
 

data/lex-llm-azure-foundry.gemspec

@@ -26,5 +26,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.4'
+  spec.add_dependency 'lex-llm', '>= 0.1.5'
 end

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

@@ -18,6 +18,8 @@ module Legion
           OPENAI_V1_SURFACE = :openai_v1
 
           class << self
+            attr_writer :registry_publisher
+
             def slug = 'azure_foundry'
             def configuration_requirements = %i[azure_foundry_endpoint]
 
@@ -34,6 +36,10 @@ module Legion
 
             def capabilities = Capabilities
 
+            def registry_publisher
+              @registry_publisher ||= RegistryPublisher.new
+            end
+
             def resolve_model_id(model_id, config: nil)
               deployment = deployment_config(model_id, config:)
               value_for(deployment, :deployment) || value_for(deployment, :model) || model_id.to_s
@@ -182,21 +188,15 @@ module Legion
           end
 
           def readiness(live: false)
-            health(live: live).merge(local: false, remote: true, endpoints: endpoint_manifest)
+            health(live: live).merge(local: false, remote: true, endpoints: endpoint_manifest).tap do |metadata|
+              self.class.registry_publisher.publish_readiness_async(metadata) if live
+            end
           end
 
           def list_models
-            discover_offerings(live: false).map do |offering|
-              Legion::Extensions::Llm::Model::Info.new(
-                id: offering.model,
-                name: offering.metadata[:canonical_model_alias] || offering.model,
-                provider: :azure_foundry,
-                family: offering.metadata[:model_family],
-                capabilities: offering.capabilities.map(&:to_s),
-                modalities: modalities_for_capabilities(offering.capabilities.map(&:to_s)),
-                metadata: offering.to_h
-              )
-            end
+            models = discover_offerings(live: false).map { |offering| model_info_from_offering(offering) }
+            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: {}) # rubocop:disable Metrics/ParameterLists
@@ -230,6 +230,19 @@ module Legion
             (config.azure_foundry_surface || MODEL_INFERENCE_SURFACE).to_sym
           end
 
+          def model_info_from_offering(offering)
+            capabilities = offering.capabilities.map(&:to_s)
+            Legion::Extensions::Llm::Model::Info.new(
+              id: offering.model,
+              name: offering.metadata[:canonical_model_alias] || offering.model,
+              provider: :azure_foundry,
+              family: offering.metadata[:model_family],
+              capabilities: capabilities,
+              modalities: modalities_for_capabilities(capabilities),
+              metadata: offering.to_h
+            )
+          end
+
           def api_version
             config.azure_foundry_api_version || DEFAULT_API_VERSION
           end

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Llm
+      module AzureFoundry
+        # Builds sanitized lex-llm registry envelopes for Azure Foundry 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 model_available(model, readiness:)
+            registry_event_class.available(
+              model_offering(model),
+              runtime: runtime_metadata,
+              health: model_health(readiness),
+              metadata: model_metadata(model)
+            )
+          end
+
+          private
+
+          def provider_offering(readiness)
+            {
+              provider_family: :azure_foundry,
+              provider_instance: provider_instance,
+              transport: :http,
+              model: 'provider-readiness',
+              usage_type: :inference,
+              capabilities: [],
+              health: readiness_health(readiness),
+              metadata: { lex: :llm_azure_foundry, provider_readiness: true }
+            }
+          end
+
+          def model_offering(model)
+            metadata = model.metadata if model.respond_to?(:metadata)
+            return metadata if metadata.is_a?(Hash) && metadata[:provider_family]
+
+            {
+              provider_family: :azure_foundry,
+              provider_instance: provider_instance,
+              transport: :http,
+              model: model.id,
+              usage_type: usage_type_for(model),
+              capabilities: Array(model.capabilities).map(&:to_sym),
+              limits: model_limits(model),
+              metadata: { lex: :llm_azure_foundry, model_name: model.name }.compact
+            }
+          end
+
+          def readiness_health(readiness)
+            health = {
+              ready: readiness[:ready] == true,
+              status: readiness[:ready] ? :available : :unavailable,
+              checked: readiness.dig(:health, :checked) != false
+            }
+            add_readiness_error(health, readiness[:health])
+          end
+
+          def add_readiness_error(health, source)
+            error = source.is_a?(Hash) ? source : {}
+            error_class = error[:error] || error['error']
+            error_message = error[:message] || error['message']
+            health[:error_class] = error_class if error_class
+            health[:error] = error_message if error_message
+            health
+          end
+
+          def model_health(readiness)
+            ready = readiness.fetch(:ready, true) == true
+            { ready:, status: ready ? :available : :degraded }
+          end
+
+          def readiness_metadata(readiness)
+            {
+              extension: :lex_llm_azure_foundry,
+              provider: :azure_foundry,
+              configured: readiness[:configured] == true,
+              live: readiness[:live] == true
+            }
+          end
+
+          def model_metadata(model)
+            { extension: :lex_llm_azure_foundry, provider: :azure_foundry, model_type: model.type }
+          end
+
+          def runtime_metadata
+            { node: provider_instance }
+          end
+
+          def model_limits(model)
+            {
+              context_window: model.context_window,
+              max_output_tokens: model.max_output_tokens
+            }.compact
+          end
+
+          def usage_type_for(model)
+            model.type == 'embedding' ? :embedding : :inference
+          end
+
+          def provider_instance
+            :azure_foundry
+          end
+
+          def registry_event_class
+            ::Legion::Extensions::Llm::Routing::RegistryEvent
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Llm
+      module AzureFoundry
+        # Best-effort publisher for Azure Foundry provider availability events.
+        class RegistryPublisher
+          APP_ID = 'lex-llm-azure-foundry'
+
+          def initialize(builder: RegistryEventBuilder.new)
+            @builder = builder
+          end
+
+          def publish_readiness_async(readiness)
+            schedule { publish_event(@builder.readiness(readiness)) }
+          end
+
+          def publish_models_async(models, readiness:)
+            schedule do
+              Array(models).each do |model|
+                publish_event(@builder.model_available(model, 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/azure_foundry/transport/messages/registry_event'
+            message_class_defined?
+          rescue LoadError
+            false
+          end
+
+          def message_class_defined?
+            defined?(::Legion::Extensions::Llm::AzureFoundry::Transport::Messages::RegistryEvent)
+          end
+
+          def message_class
+            ::Legion::Extensions::Llm::AzureFoundry::Transport::Messages::RegistryEvent
+          end
+
+          def log_publish_failure(error, level: :warn)
+            message = "[lex-llm-azure-foundry] 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/azure_foundry/transport/exchanges/llm_registry.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Llm
+      module AzureFoundry
+        module Transport
+          module Exchanges
+            # Topic exchange for Azure Foundry 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/azure_foundry/transport/messages/registry_event.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/llm/azure_foundry/transport/exchanges/llm_registry'
+
+module Legion
+  module Extensions
+    module Llm
+      module AzureFoundry
+        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/azure_foundry/version.rb

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module AzureFoundry
-        VERSION = '0.1.0'
+        VERSION = '0.1.2'
       end
     end
   end

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

@@ -2,6 +2,8 @@
 
 require 'legion/extensions/llm'
 require 'legion/extensions/llm/azure_foundry/provider'
+require 'legion/extensions/llm/azure_foundry/registry_event_builder'
+require 'legion/extensions/llm/azure_foundry/registry_publisher'
 require 'legion/extensions/llm/azure_foundry/version'
 
 module Legion

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-azure-foundry
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - LegionIO
@@ -57,14 +57,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.4
+        version: 0.1.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.4
+        version: 0.1.5
 description: Azure AI Foundry and Azure OpenAI hosted provider integration for LegionIO
   LLM routing.
 email:
@@ -85,6 +85,10 @@ files:
 - lex-llm-azure-foundry.gemspec
 - lib/legion/extensions/llm/azure_foundry.rb
 - lib/legion/extensions/llm/azure_foundry/provider.rb
+- lib/legion/extensions/llm/azure_foundry/registry_event_builder.rb
+- lib/legion/extensions/llm/azure_foundry/registry_publisher.rb
+- lib/legion/extensions/llm/azure_foundry/transport/exchanges/llm_registry.rb
+- lib/legion/extensions/llm/azure_foundry/transport/messages/registry_event.rb
 - lib/legion/extensions/llm/azure_foundry/version.rb
 homepage: https://github.com/LegionIO/lex-llm-azure-foundry
 licenses: