lex-llm-azure-foundry 0.1.4 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 188c4529d8f3fb9fcde5080b22e3768fbe713b609fc86efb1264a1e8595c6bb5
-  data.tar.gz: 3826e3576537bb8b1ba7d26bc4f91a061dbf023578bf21b232b90fe7269981c1
+  metadata.gz: 279b43dc868c44a7b0f39f737cfff512ee6f5383097b886c5ceb77da7cbb6367
+  data.tar.gz: 8c6d1c95608344743ae5ebbf181cd9eb016dc389ddb88efb9a338bf7590112a4
 SHA512:
-  metadata.gz: bec5704b0a9a1465b0e2404e0eeb436ab22026c3112d47a386b561f1b20c58a09326757d9c180aaf47fbc7a108f8f9f3267710639ae779803ff8a1bc17bea751
-  data.tar.gz: 7b88529d1438f19a893e5d34839bea59b0a2c733a1e273ef0dcc0447fe929a7f44374316bd1377270dfd0036c2adcd24f10f6b8b42bd24a5a7ef98acab733c30
+  metadata.gz: 98254832116e7e04fc487d0477a791f0aac57fa2123035b87d8ca73d6e88c4691706f0ee23c95fdd8833db77898646ec21378d4eaf6faa799b46840d695732a4
+  data.tar.gz: fc8551e98c53413ad263b0e78903a24c2d1e2ee49822bba32a5a2e183d5a205af5e1fc00af80cd8f1b6501b02638f5a22286741ea800caf2267ad200438040f7

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [0.1.6] - 2026-05-01
+
+- Require lex-llm >= 0.1.9 for the shared base contract
+- Replace local RegistryPublisher and RegistryEventBuilder with base classes from lex-llm
+- Delete local transport/ directory (exchange and message classes now live in lex-llm)
+- Remove deprecated Provider.register call; use Configuration.register_provider_options directly
+- Simplify default_settings to flat provider hash (no provider_settings builder)
+- Fix Model::Info construction to use modalities_input/modalities_output keywords
+
+## [0.1.5] - 2026-04-30
+
+- Audit all rescue blocks for handle_exception compliance across Provider, RegistryPublisher, and RegistryEventBuilder
+- Add Legion::Logging::Helper to AzureFoundry module, RegistryPublisher, and RegistryEventBuilder
+- Add info-level action logging for discover_offerings, health, readiness, list_models, chat, stream, embed, and registry publish
+- Remove custom log_publish_failure in favour of standard handle_exception
+- Update README to reflect current architecture, file map, and observability
+
 ## [0.1.4] - 2026-04-30
 
 - Enable stream_usage_supported? for streaming token usage reporting

data/README.md

@@ -13,11 +13,49 @@ Load it with `require 'legion/extensions/llm/azure_foundry'`.
 - Azure AI Foundry model inference embeddings through `POST /models/embeddings?api-version=...`
 - Azure AI Foundry model info health check through `GET /models/info?api-version=...` when `live: true`
 - Azure OpenAI v1-compatible endpoint support through `/openai/v1/chat/completions` and `/openai/v1/embeddings`
-- deployment-name-preserving routing offerings for hosted Azure deployments
-- explicit `model_family` and `canonical_model_alias` metadata for deployments whose base model cannot be proven from Azure metadata
-- offline-first discovery from configured deployments
-- shared OpenAI-compatible request and response mapping via `Legion::Extensions::Llm::Provider::OpenAICompatible`
-- conservative token-counting metadata when no portable Azure token-counting REST endpoint is configured
+- Deployment-name-preserving routing offerings for hosted Azure deployments
+- Explicit `model_family` and `canonical_model_alias` metadata for deployments whose base model cannot be proven from Azure metadata
+- Offline-first discovery from configured deployments
+- Shared OpenAI-compatible request and response mapping via `Legion::Extensions::Llm::Provider::OpenAICompatible`
+- Conservative token-counting metadata when no portable Azure token-counting REST endpoint is configured
+- Best-effort `llm.registry` event publishing for readiness and model availability via AMQP when transport is available
+
+## Architecture
+
+```
+Legion::Extensions::Llm::AzureFoundry
+├── Provider              # Azure AI Foundry and Azure OpenAI hosted provider surface
+│   └── Capabilities      # Capability predicates inferred from deployment metadata and model naming
+├── RegistryPublisher     # Best-effort async publisher for llm.registry availability events
+├── RegistryEventBuilder  # Builds sanitized lex-llm registry envelopes for provider state
+├── Transport/
+│   ├── Messages::RegistryEvent  # AMQP message for llm.registry events
+│   └── Exchanges::LlmRegistry  # Topic exchange for provider availability events
+└── VERSION
+```
+
+## File Map
+
+| Path | Purpose |
+|------|---------|
+| `lib/legion/extensions/llm/azure_foundry.rb` | Entry point, provider registration, default settings |
+| `lib/legion/extensions/llm/azure_foundry/provider.rb` | Provider implementation with chat, stream, embed, health, readiness, discovery |
+| `lib/legion/extensions/llm/azure_foundry/registry_publisher.rb` | Async registry event publishing with transport guards |
+| `lib/legion/extensions/llm/azure_foundry/registry_event_builder.rb` | Sanitized registry envelope construction |
+| `lib/legion/extensions/llm/azure_foundry/transport/messages/registry_event.rb` | AMQP message class for registry events |
+| `lib/legion/extensions/llm/azure_foundry/transport/exchanges/llm_registry.rb` | Topic exchange definition for llm.registry |
+| `lib/legion/extensions/llm/azure_foundry/version.rb` | `VERSION` constant |
+
+## Observability
+
+Every class and module uses `Legion::Logging::Helper`:
+
+- **AzureFoundry** module: `extend Legion::Logging::Helper`
+- **Provider**: inherits `include Legion::Logging::Helper` from `Legion::Extensions::Llm::Provider`
+- **RegistryPublisher**: `include Legion::Logging::Helper`
+- **RegistryEventBuilder**: `include Legion::Logging::Helper`
+
+All rescue blocks call `handle_exception(e, level:, handled:, operation:)` for structured exception reporting. Key actions emit info-level log lines including discover_offerings, health checks, readiness, model listing, chat, stream, embed, and registry publish operations.
 
 ## API Contract
 
@@ -97,6 +135,8 @@ provider = Legion::Extensions::Llm::AzureFoundry.provider_class.new(Legion::Exte
 provider.discover_offerings(live: false)
 provider.offering_for(model: "gpt-4o-prod", model_family: :openai, canonical_model_alias: "gpt-4o")
 provider.health(live: false)
+provider.readiness(live: false)
+provider.list_models
 provider.chat(messages, model: "gpt-4o-prod")
 provider.stream(messages, model: "gpt-4o-prod") { |chunk| puts chunk.content }
 provider.embed(["hello"], model: "embedding-prod")

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.5'
+  spec.add_dependency 'lex-llm', '>= 0.2.0'
 end

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

@@ -17,8 +17,6 @@ module Legion
           OPENAI_V1_SURFACE = :openai_v1
 
           class << self
-            attr_writer :registry_publisher
-
             def slug = 'azure_foundry'
             def configuration_requirements = %i[azure_foundry_endpoint]
 
@@ -36,7 +34,7 @@ module Legion
             def capabilities = Capabilities
 
             def registry_publisher
-              @registry_publisher ||= RegistryPublisher.new
+              AzureFoundry.registry_publisher
             end
 
             def resolve_model_id(model_id, config: nil)
@@ -144,12 +142,14 @@ module Legion
           def health_url = models_url
 
           def discover_offerings(live: false, **filters)
+            log.info { "discovering offerings live=#{live} from #{api_base}" }
             offerings = configured_deployments.filter_map { |deployment| offering_from_config(deployment) }
             return filter_offerings(offerings, **filters) unless live
 
             filter_offerings(offerings, **filters).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
@@ -172,43 +172,43 @@ module Legion
           end
 
           def health(live: false)
-            baseline = {
-              provider: :azure_foundry,
-              configured: configured?,
-              ready: configured?,
-              live: live,
-              api_base: api_base,
-              surface: surface
-            }
+            log.info { "checking health live=#{live} at #{api_base}" }
+            baseline = health_baseline(live)
             return baseline.merge(checked: false) unless live
 
             response = connection.get(health_url)
             baseline.merge(checked: true, model_info: 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)
           end
 
           def readiness(live: false)
+            log.info { "checking readiness live=#{live} at #{api_base}" }
             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
+            log.info { "listing configured deployment models from #{api_base}" }
             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
+            log.info { "chat request model=#{model} messages=#{messages.size}" }
             complete(messages, tools:, temperature:, model: model_info(model, max_tokens:), params:, tool_prefs:)
           end
 
           def stream(messages, model:, temperature: nil, max_tokens: nil, tools: {}, tool_prefs: nil, params: {}, &) # rubocop:disable Metrics/ParameterLists
+            log.info { "stream request model=#{model} messages=#{messages.size}" }
             complete(messages, tools:, temperature:, model: model_info(model, max_tokens:), params:, tool_prefs:, &)
           end
 
           def embed(text, model:, dimensions: nil, input_type: nil)
+            log.info { "embed request model=#{model}" }
             payload = render_embedding_payload(text, model: model_id(model), dimensions:)
             payload[:input_type] = input_type if input_type
             response = connection.post(embedding_url(model:), payload)
@@ -231,15 +231,28 @@ module Legion
             (config.azure_foundry_surface || MODEL_INFERENCE_SURFACE).to_sym
           end
 
+          def health_baseline(live)
+            {
+              provider: :azure_foundry,
+              configured: configured?,
+              ready: configured?,
+              live: live,
+              api_base: api_base,
+              surface: surface
+            }
+          end
+
           def model_info_from_offering(offering)
             capabilities = offering.capabilities.map(&:to_s)
+            modalities = modalities_for_capabilities(capabilities)
             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),
+              modalities_input: modalities[:input],
+              modalities_output: modalities[:output],
               metadata: offering.to_h
             )
           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.4'
+        VERSION = '0.1.6'
       end
     end
   end

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

@@ -2,8 +2,6 @@
 
 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
@@ -12,38 +10,38 @@ module Legion
       # Azure AI Foundry provider extension namespace.
       module AzureFoundry
         extend ::Legion::Extensions::Core if ::Legion::Extensions.const_defined?(:Core, false)
+        extend Legion::Logging::Helper
 
         PROVIDER_FAMILY = :azure_foundry
 
         def self.default_settings
-          ::Legion::Extensions::Llm.provider_settings(
-            family: PROVIDER_FAMILY,
-            discovery: { enabled: true, live: false },
-            instance: {
-              endpoint: 'https://<resource>.services.ai.azure.com',
-              api_version: '2024-05-01-preview',
-              surface: :model_inference,
-              tier: :frontier,
-              transport: :http,
-              credentials: {
-                api_key: 'env://AZURE_INFERENCE_CREDENTIAL',
-                bearer_token: 'env://AZURE_FOUNDRY_BEARER_TOKEN',
-                entra_scope: 'https://cognitiveservices.azure.com/.default'
-              },
-              deployments: [],
-              usage: { inference: true, embedding: true, token_counting: false },
-              limits: { concurrency: 4 }
-            }
-          )
+          {
+            enabled: false,
+            default_model: nil,
+            endpoint: nil,
+            api_key: nil,
+            bearer_token: nil,
+            api_version: '2024-05-01-preview',
+            surface: nil,
+            deployments: [],
+            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
+
+        Legion::Extensions::Llm::Configuration.register_provider_options(Provider.configuration_options)
       end
     end
   end
 end
-
-Legion::Extensions::Llm::Provider.register(Legion::Extensions::Llm::AzureFoundry::PROVIDER_FAMILY,
-                                           Legion::Extensions::Llm::AzureFoundry::Provider)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-azure-foundry
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
 platform: ruby
 authors:
 - LegionIO
@@ -57,14 +57,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: Azure AI Foundry and Azure OpenAI hosted provider integration for LegionIO
   LLM routing.
 email:
@@ -85,10 +85,6 @@ 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:

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

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

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

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

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