lex-llm-azure-foundry 0.2.7 → 0.2.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2685de78719c6f5733c93f2b9b66bfbc568115fa40c332754a7ce27ce2cf74ea
-  data.tar.gz: 4af76d69f22a4c6df093e4916def72c7e7b13ff5c27589e9db099dc815dad051
+  metadata.gz: 76e76ee4edefeb764f3d1829a900e1bf60bf9ccc598532feb0d6033680af329f
+  data.tar.gz: 778667f3720744c2b5ea38e96d52db29d22c4228f4247a55e9976fd2e1b85612
 SHA512:
-  metadata.gz: 520b040a7aadd89ce62fe7213a4c1a16d2a769ab0236e9672b47635157c445957cb52d58dcae63e5231aa3070e1e4b8be2104785383b5e7042da82d74c3ecf51
-  data.tar.gz: 91c9bdf31e9767f1f93e1ac2bc85ae07a73974bd9be5959c7e3f1281161036bcc26fed59eed7766cba813148db9a8aefcdd1600e409b379adbd5f23198337999
+  metadata.gz: f1facb1bad185f1b7d2429213869f637598802d078ea1bf453c670de3ff5426f56e763d0102e3b15ce78f4afb6bd36788bf7269918416191b0daa483e5ae6ca4
+  data.tar.gz: aa1a7c88250da3f1d676ef92fbb0f46522d44994e54d49707daad0ec38eb0e940341ea4f9b0661af9d117771b4fe5d3e4156a3c29d21a11b74446dd9fdbd9570

data/CHANGELOG.md

@@ -1,5 +1,40 @@
 # Changelog
 
+## [0.2.13] - 2026-06-20
+
+### Fixed
+- Stub shared registry publishing through `RegistryPublisher#schedule` in specs so async availability-event coverage stays stable after the shared publisher moved off raw `Thread.new`.
+
+## [0.2.12] - 2026-06-20
+
+### Changed
+- Align Azure Foundry instance discovery with the shared `lex-llm` contract by preserving explicit tier overrides while defaulting unconfigured instances to `:cloud`.
+- Restore offline deployment-backed offering discovery and carry the configured provider instance id through Azure offering metadata.
+- Normalize Azure Foundry capability and health metadata to the current shared offering contract.
+
+## [0.2.11] - 2026-06-19
+
+### Changed
+- Adopt `Legion::Extensions::Llm::Inventory::ScopedRefresher` mixin (lex-llm 0.6.0). Discovery
+  refresh actors now write directly to the live `Inventory` catalog via `Inventory.write_lane`.
+- Pin `lex-llm >= 0.6.0` and `legion-llm >= 0.14.0` in gemspec.
+- Standard `weight: 100` default added to provider instance settings schema.
+
+## 0.2.10 - 2026-06-16
+
+- Dependency updates and code quality improvements.
+
+## 0.2.9 - 2026-06-15
+
+- **CapabilityPolicy integration** — Streaming from `:provider_envelope`; deployment metadata as `:model_metadata`. Settings overrides at provider/instance/model level supported.
+
+## 0.2.8 - 2026-06-13
+
+- **Gemfile cleanup** — Remove local path overrides; dependencies resolve from gemspec via rubygems.
+- **Dependency bump** — Require `lex-llm >= 0.5.0` for canonical types support.
+- **Capabilities** — Add canonical `:tools` to capability declarations.
+- 26 examples, 0 failures; 13 files, 0 rubocop offenses.
+
 ## 0.2.7 - 2026-06-02
 
 - Add per-provider scoped discovery refresh actor

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-azure-foundry.gemspec

@@ -27,5 +27,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.6.0'
 end

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

@@ -1,11 +1,19 @@
 # frozen_string_literal: true
 
+require 'digest'
+
 begin
   require 'legion/extensions/actors/every'
 rescue LoadError => e
   warn(e.message) if $VERBOSE
 end
 
+begin
+  require 'legion/extensions/llm/inventory/scoped_refresher'
+rescue LoadError => e
+  warn(e.message) if $VERBOSE
+end
+
 return unless defined?(Legion::Extensions::Actors::Every)
 
 module Legion
@@ -13,10 +21,16 @@ module Legion
     module Llm
       module AzureFoundry
         module Actor
-          class DiscoveryRefresh < Legion::Extensions::Actors::Every # rubocop:disable Style/Documentation
+          class DiscoveryRefresh < Legion::Extensions::Actors::Every # rubocop:disable Style/Documentation,Metrics/ClassLength
             include Legion::Logging::Helper
 
-            REFRESH_INTERVAL = 1800
+            if defined?(Legion::Extensions::Llm::Inventory::ScopedRefresher)
+              include Legion::Extensions::Llm::Inventory::ScopedRefresher
+            end
+
+            EMBED_TYPES = %i[embed embedding].freeze
+
+            def self.every_seconds = 3600
 
             def runner_class    = self.class
             def runner_function = 'manual'
@@ -26,19 +40,131 @@ module Legion
             def generate_task?  = false
 
             def time
-              return REFRESH_INTERVAL unless defined?(Legion::Settings)
+              return self.class.every_seconds unless defined?(Legion::Settings)
 
-              Legion::Settings.dig(:extensions, :llm, :azure_foundry, :discovery_interval) || REFRESH_INTERVAL
+              Legion::Settings.dig(:extensions, :llm, :azure_foundry, :discovery_interval) || self.class.every_seconds
             end
 
-            def manual
+            def manual # rubocop:disable Metrics/CyclomaticComplexity
               log.debug('[azure_foundry][discovery_refresh] refreshing model list')
+              tick if respond_to?(:tick)
+
               return unless defined?(Legion::LLM::Discovery)
 
               Legion::LLM::Discovery.refresh_discovered_models!(provider: :azure_foundry)
+
+              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: 'azure_foundry.actor.discovery_refresh')
             end
+
+            def scope_key(**)
+              { provider: :azure_foundry }
+            end
+
+            def compute_lanes_for_scope(**)
+              return [] unless defined?(Legion::LLM::Call::Registry)
+
+              instances = Legion::LLM::Call::Registry.all_instances.select do |e|
+                (e[:provider] || '').to_sym == :azure_foundry
+              end
+
+              lanes = []
+              instances.each { |entry| collect_instance_lanes(entry, lanes) }
+              lanes
+            rescue StandardError => e
+              handle_exception(e, level: :warn, handled: true,
+                                  operation: 'azure_foundry.compute_lanes_for_scope')
+              []
+            end
+
+            def credential_hash(**)
+              settings = Legion::Settings.dig(:extensions, :llm, :azure_foundry) || {}
+              ::Digest::SHA256.hexdigest(settings[:api_key].to_s + settings[:instances].to_s)[0, 16]
+            rescue StandardError
+              'unknown'
+            end
+
+            private
+
+            def collect_instance_lanes(instance_entry, lanes)
+              adapter = instance_entry[:adapter]
+              return unless adapter.respond_to?(:discover_offerings)
+
+              Array(adapter.discover_offerings(live: true)).each do |offering|
+                build_and_append_lanes(offering, instance_entry, lanes)
+              end
+            rescue StandardError => e
+              handle_exception(e, level: :warn, handled: true,
+                                  operation: 'azure_foundry.compute_lanes_for_scope.instance')
+            end
+
+            def build_and_append_lanes(offering, instance_entry, lanes)
+              raw = offering.respond_to?(:to_h) ? offering.to_h : offering
+              return unless raw.is_a?(Hash)
+
+              lane = build_lane(raw, instance_entry)
+              lanes << lane
+              lanes << lane.merge(id: fleet_id_for(lane), tier: :fleet) if fleet_enabled? && lane[:type] == :inference
+            end
+
+            def build_lane(raw, instance_entry) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+              model       = raw[:model] || raw['model']
+              instance_id = raw[:instance_id] || raw['instance_id'] ||
+                            instance_entry[:instance] || instance_entry[:instance_id] ||
+                            instance_entry[:id] || :default
+              pf          = raw[:provider_family] || raw['provider_family'] || :azure_foundry
+              type        = resolve_type(raw)
+              tier        = (raw[:tier] || raw['tier'] || :cloud).to_sym
+              lane_id     = compose_lane_id(tier: tier, provider_family: pf, instance_id: instance_id,
+                                            type: type, model: model)
+
+              {
+                id: lane_id,
+                tier: tier,
+                provider_family: pf,
+                instance_id: instance_id,
+                model: model,
+                canonical_model_alias: raw[:canonical_model_alias] || raw['canonical_model_alias'],
+                type: type,
+                capabilities: normalize_capabilities(raw[:capabilities] || raw['capabilities'] || []),
+                limits: raw[:limits] || raw['limits'] || {},
+                enabled: raw.fetch(:enabled, raw.fetch('enabled', true)),
+                cost: raw[:cost] || raw['cost'] || {}
+              }
+            end
+
+            def resolve_type(raw)
+              val = raw[:type] || raw['type'] || raw[:usage_type] || raw['usage_type']
+              EMBED_TYPES.include?(val&.to_sym) ? :embedding : :inference
+            end
+
+            def normalize_capabilities(raw)
+              if defined?(Legion::Extensions::Llm::Inventory::Capabilities)
+                Legion::Extensions::Llm::Inventory::Capabilities.normalize(raw)
+              else
+                Array(raw)
+              end
+            end
+
+            def compose_lane_id(**fields)
+              Legion::Extensions::Llm::Inventory::ScopedRefresher.compose_id(fields)
+            end
+
+            def fleet_id_for(lane)
+              compose_lane_id(tier: :fleet, provider_family: lane[:provider_family],
+                              instance_id: lane[:instance_id], type: lane[:type], model: lane[:model])
+            end
+
+            def fleet_enabled?
+              settings = Legion::Settings.dig(:extensions, :llm, :azure_foundry) || {}
+              settings[:fleet]&.dig(:dispatch, :enabled)
+            end
           end
         end
       end

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

@@ -121,6 +121,10 @@ module Legion
 
           def stream_usage_supported? = true
 
+          def settings
+            AzureFoundry.default_settings.dig(:instances, :default)
+          end
+
           def api_base
             endpoint = config.azure_foundry_endpoint.to_s.sub(%r{/*\z}, '')
             return "#{endpoint}/openai/v1" if surface == OPENAI_V1_SURFACE && !endpoint.end_with?('/openai/v1')
@@ -143,29 +147,17 @@ module Legion
           def embedding_url(**) = path_for('embeddings')
           def health_url = models_url
 
-          def discover_offerings(live: false, **filters)
-            log.info { "discovering offerings live=#{live} from #{api_base}" }
-            offerings = filter_offerings(allowed_offerings, **filters)
-            return offerings unless live
-
-            offerings.map do |offering|
-              with_live_metadata(offering)
-            rescue StandardError => e
-              handle_exception(e, level: :warn, handled: true, operation: 'azure_foundry.discover_offerings')
-              with_health(offering, ready: false, checked: true, error: e)
-            end
-          end
-
-          def offering_for(model:, model_family: nil, canonical_model_alias: nil, instance_id: :default, # rubocop:disable Metrics/ParameterLists
+          def offering_for(model:, model_family: nil, canonical_model_alias: nil, instance_id: nil, # rubocop:disable Metrics/ParameterLists, Metrics/AbcSize
                            usage_type: nil, **metadata)
             deployment = self.class.deployment_config(model, config:)
             model_id = self.class.resolve_model_id(model, config:)
             configured_family = value_for(deployment, :model_family)
             configured_alias = value_for(deployment, :canonical_model_alias)
+            resolved_instance_id = instance_id || provider_instance_id
 
             build_offering(
               model: model_id,
-              instance_id: instance_id,
+              instance_id: resolved_instance_id,
               model_family: normalize_family(model_family || configured_family || infer_model_family(model_id)),
               canonical_model_alias: canonical_model_alias || configured_alias,
               usage_type: usage_type || value_for(deployment, :usage_type) || usage_type_for(model_id),
@@ -179,10 +171,12 @@ module Legion
             return baseline.merge(checked: false) unless live
 
             response = connection.get(health_url)
-            baseline.merge(checked: true, model_info: response.body)
+            baseline.merge(checked: true, ready: true, status: 'healthy', circuit_state: 'closed',
+                           raw: response.body)
           rescue StandardError => e
             handle_exception(e, level: :warn, handled: true, operation: 'azure_foundry.health')
-            baseline.merge(checked: true, ready: false, error: e.class.name, message: e.message)
+            baseline.merge(checked: true, ready: false, status: 'unhealthy', circuit_state: 'open',
+                           error: e.class.name, message: e.message)
           end
 
           def readiness(live: false)
@@ -258,11 +252,15 @@ module Legion
           end
 
           def health_baseline(live)
+            ready = configured?
             {
               provider: :azure_foundry,
-              configured: configured?,
-              ready: configured?,
+              instance_id: provider_instance_id,
+              configured: ready,
+              ready: ready,
               live: live,
+              status: ready ? 'healthy' : 'unhealthy',
+              circuit_state: ready ? 'closed' : 'open',
               api_base: api_base,
               surface: surface
             }
@@ -298,6 +296,20 @@ module Legion
             token ? "Bearer #{token}" : nil
           end
 
+          def discover_offerings(live: false, raise_on_unreachable: false, **filters)
+            offerings = allowed_offerings
+            return filter_offerings(offerings, **filters) unless live
+
+            resolved = offerings.map { |offering| with_live_metadata(offering) }
+            filter_offerings(resolved, **filters)
+          rescue Faraday::ConnectionFailed, Faraday::TimeoutError => e
+            log.warn("[#{slug}] instance=#{provider_instance_id} unreachable: #{e.message}")
+            raise if raise_on_unreachable
+
+            []
+          end
+          public :discover_offerings
+
           def configured_deployments
             self.class.normalize_deployments(config.azure_foundry_deployments)
           end
@@ -315,21 +327,39 @@ module Legion
           end
 
           def offering_from_config(deployment)
-            deployment_name = value_for(deployment, :deployment) || value_for(deployment, :model)
-            return nil if deployment_name.to_s.empty?
-
             offering_for(
-              model: deployment_name,
+              model: value_for(deployment, :deployment) || value_for(deployment, :model),
               model_family: value_for(deployment, :model_family),
               canonical_model_alias: value_for(deployment, :canonical_model_alias),
-              instance_id: value_for(deployment, :instance_id) || :default,
-              usage_type: value_for(deployment, :usage_type),
-              configured: true
+              instance_id: provider_instance_id,
+              usage_type: value_for(deployment, :usage_type) || :inference,
+              metadata: deployment_metadata(deployment)
+            )
+          end
+
+          def offering_from_model(model_info, _health: nil) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+            model_id = model_info.respond_to?(:id) ? model_info.id : model_info['id']
+            name = model_info.respond_to?(:name) ? model_info.name : model_info['name'] || model_id
+            family = model_info.respond_to?(:family) ? model_info.family : model_info['model_family']
+            usage = model_info.respond_to?(:embedding?) && model_info.embedding? ? :embedding : :inference
+            meta = if model_info.respond_to?(:metadata)
+                     model_info.metadata
+                   else
+                     model_info.is_a?(Hash) ? model_info : {}
+                   end
+
+            offering_for(
+              model: model_id,
+              model_family: family,
+              canonical_model_alias: name,
+              instance_id: provider_instance_id,
+              usage_type: usage,
+              metadata: meta
             )
           end
 
           def build_offering(model:, model_family:, usage_type:, instance_id:, canonical_model_alias:, metadata:) # rubocop:disable Metrics/ParameterLists
-            capabilities = capabilities_for(model, usage_type)
+            policy = resolve_capability_policy(model, usage_type)
             Legion::Extensions::Llm::Routing::ModelOffering.new(
               provider_family: :azure_foundry,
               instance_id: instance_id,
@@ -337,7 +367,8 @@ module Legion
               tier: offering_tier,
               model: model,
               usage_type: usage_type.to_sym,
-              capabilities: capabilities,
+              capabilities: policy[:capabilities],
+              capability_sources: policy[:sources],
               metadata: metadata.merge(
                 model_family: model_family,
                 canonical_model_alias: canonical_model_alias,
@@ -373,6 +404,65 @@ module Legion
             deployment.to_h.transform_keys(&:to_sym).except(:deployment, :model_family, :usage_type)
           end
 
+          def resolve_capability_policy(model, usage_type)
+            if usage_type.to_sym == :embedding
+              return { capabilities: %i[embedding], sources: { embedding: { value: true, source: :model_metadata } } }
+            end
+
+            real_caps = real_capabilities_for(model)
+            provider_cfg = provider_level_config
+            instance_cfg = instance_level_config
+            model_cfg = model_config_for(model)
+
+            Legion::Extensions::Llm::CapabilityPolicy.resolve(
+              real: real_caps,
+              provider_catalog: {},
+              probe: {},
+              provider_envelope: { streaming: true },
+              provider_config: provider_cfg,
+              instance_config: instance_cfg,
+              model_config: model_cfg
+            )
+          end
+
+          def real_capabilities_for(model)
+            caps = {}
+            caps[:streaming] = true if Capabilities.streaming?(model)
+            caps[:tools] = true if Capabilities.functions?(model)
+            caps[:vision] = true if Capabilities.vision?(model)
+            caps
+          end
+
+          def instance_level_config
+            if config.respond_to?(:to_h)
+              config.to_h
+            elsif config.respond_to?(:instance_variable_get)
+              data = config.instance_variable_get(:@data)
+              data.is_a?(Hash) ? data : {}
+            else
+              {}
+            end
+          end
+
+          def provider_level_config
+            cfg = Legion::Extensions::Llm::CredentialSources.setting(:extensions, :llm, :azure_foundry)
+            return {} unless cfg.is_a?(Hash)
+
+            cfg.except(:instances, 'instances')
+          rescue StandardError => e
+            handle_exception(e, level: :warn, handled: true, operation: 'azure_foundry.provider_level_config')
+            {}
+          end
+
+          def model_config_for(model)
+            provider_cfg = provider_level_config
+            models = provider_cfg[:models] || provider_cfg['models']
+            return {} unless models.is_a?(Hash)
+
+            model_id_str = Capabilities.model_id(model)
+            models[model_id_str.to_sym] || models[model_id_str] || {}
+          end
+
           def capabilities_for(model, usage_type)
             return %i[embedding] if usage_type.to_sym == :embedding
 

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module AzureFoundry
-        VERSION = '0.2.7'
+        VERSION = '0.2.13'
       end
     end
   end

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

@@ -3,6 +3,7 @@
 require 'legion/extensions/llm'
 require 'legion/extensions/llm/azure_foundry/provider'
 require 'legion/extensions/llm/azure_foundry/version'
+require_relative 'azure_foundry/actors/discovery_refresh'
 
 module Legion
   module Extensions
@@ -36,10 +37,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]
               }
             }
           )
@@ -68,7 +66,7 @@ module Legion
                      cfg['api_base']
           return if endpoint.nil? || endpoint.to_s.strip.empty?
 
-          instances[:settings] = normalize_instance_config(cfg).merge(tier: :cloud)
+          instances[:settings] = normalize_instance_config(cfg).merge(tier: cfg[:tier] || cfg['tier'] || :cloud)
         end
 
         def self.discover_named_instances(instances)
@@ -88,7 +86,8 @@ module Legion
                      config[:api_base] || config['api_base']
           return if endpoint.nil? || endpoint.to_s.strip.empty?
 
-          instances[name.to_sym] = normalize_instance_config(config).merge(tier: :cloud)
+          instances[name.to_sym] =
+            normalize_instance_config(config).merge(tier: config[:tier] || config['tier'] || :cloud)
         end
 
         def self.normalize_instance_config(config) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
@@ -107,8 +106,7 @@ module Legion
         private_class_method :discover_default_instance, :discover_named_instances, :add_named_instance,
                              :normalize_instance_config
 
-        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-azure-foundry
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.2.13
 platform: ruby
 authors:
 - LegionIO
@@ -71,14 +71,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.3
+        version: 0.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.3
+        version: 0.6.0
 description: Azure AI Foundry and Azure OpenAI hosted provider integration for LegionIO
   LLM routing.
 email: