lex-llm-azure-foundry 0.2.0 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 816c51165a46a9e5f15c3e535da382dc2459f6cca39b53644b60b2fb090196b9
-  data.tar.gz: 5ddf21d6404a9a255d4e3ef30c0b3a4c36989c7e217558b2a00da050f5149093
+  metadata.gz: be5a0deef7be2d2f074ec98ebb5a77ec065d46029c7d4a902479bdfc2044240d
+  data.tar.gz: 565fe0757d88c7f8289c919d721db319303e25ef906f96982fd18179d1135845
 SHA512:
-  metadata.gz: 266af948f19a52cf3b7612c43641daab824a16ffd0b1a06a344184ef5724b30b1b138b85a915459f70fe431c4df80e2e388f884c64e7e10300ecbc590afbef1d
-  data.tar.gz: bf925fbf1fe563c47f6e4adf244e6a2468c0c5d198f273515ba98d91fb54a7029dc0315e3520ceda8ef289fd15791358ed441766e4639b60ac708f14c1f43c88
+  metadata.gz: 3503088b0c52dedeb98dc49bdbf8006836e038a71c0b0600e5aaaa89302c0e10c4f9963de7d583445fc98910520bd1bed89793b9c9776b7e95cf0d0b6d3d9215
+  data.tar.gz: bc52d6be469507ffa3fd886ccab511c345d34c568432b2e94c8e6f89c302d597d12f1fffffa61e2e6206f25e149c0590180c2d40ff28d6a17ad5c9baec3071ec

data/.github/workflows/ci.yml

@@ -8,8 +8,20 @@ jobs:
   ci:
     uses: LegionIO/.github/.github/workflows/ci.yml@main
 
+  excluded-files:
+    uses: LegionIO/.github/.github/workflows/excluded-files.yml@main
+
+  security:
+    uses: LegionIO/.github/.github/workflows/security-scan.yml@main
+
+  version-changelog:
+    uses: LegionIO/.github/.github/workflows/version-changelog.yml@main
+
+  dependency-review:
+    uses: LegionIO/.github/.github/workflows/dependency-review.yml@main
+
   release:
-    needs: ci
+    needs: [ci, excluded-files, security]
     if: github.event_name == 'push' && github.ref == 'refs/heads/main'
     uses: LegionIO/.github/.github/workflows/release.yml@main
     secrets:

data/CHANGELOG.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## 0.2.6 - 2026-05-21
+
+- Add `default_transport`/`default_tier` class declarations, remove `configured_transport`/`configured_tier`
+- Add `model_allowed?` filtering in `discover_offerings`
+- Default tier set to :cloud
+- Identity headers included via base provider
+
+
+## 0.2.5 - 2026-05-06
+
+- Load provider-owned fleet actors through the LegionIO subscription base and the canonical Azure Foundry provider root.
+- Keep fleet runners anchored on the provider root namespace so provider constants and instance discovery are always loaded.
+- Preserve configured transport and tier metadata when Azure Foundry builds routing offerings.
+- Gate release publishing on the shared security workflow.
+
+## 0.2.4 - 2026-05-06
+
+- Use the shared `lex-llm` fleet provider responder helper for provider-owned fleet workers.
+- Remove the runtime `legion-llm` dependency and require `lex-llm >= 0.4.3` for responder-side fleet execution.
+
+## 0.2.3 - 2026-05-06
+
+- Remove require-time provider self-registration; `legion-llm` now owns adapter creation and registry writes from loaded provider discovery metadata.
+- Bump dependency floors to `lex-llm >= 0.4.1` and `legion-llm >= 0.9.1`.
+
+## 0.2.2 - 2026-05-06
+
+- Enforce the shared keyword-only `lex-llm` provider contract for chat, embeddings, and token counting.
+- Move defaults back to `Legion::Extensions::Llm.provider_settings` with credentials/provider metadata under the default instance and instance-level fleet responder settings.
+- Add provider-owned fleet responder actor and runner backed by `legion-llm` fleet policy execution.
+- Bump the transport dependency floor to `legion-transport >= 1.4.14`.
+
+## 0.2.1 - 2026-05-03
+
+- Normalize generic settings keys to Azure Foundry provider config keys during instance discovery.
+
 ## 0.2.0 - 2026-05-01
 
 - Add auto-discovery via CredentialSources and AutoRegistration from lex-llm 0.3.0

data/Gemfile

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

data/README.md

@@ -2,153 +2,179 @@
 
 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 >= 0.1.5` for shared provider-neutral routing, fleet, model-offering, readiness, canonical-alias, and schema primitives.
+This gem lives under `Legion::Extensions::Llm::AzureFoundry`. It depends on `lex-llm >= 0.4.3` for provider contracts, routing metadata, registry publishing helpers, and provider-owned fleet request handling. It does not require or depend on `legion-llm` at runtime; Legion LLM orchestration can load this provider gem and consume its discovery metadata.
 
-Load it with `require 'legion/extensions/llm/azure_foundry'`.
+Load it with:
+
+```ruby
+require 'legion/extensions/llm/azure_foundry'
+```
 
 ## What It Provides
 
-- `Legion::Extensions::Llm::Provider` registration as `:azure_foundry`
+- Provider family `:azure_foundry`
 - Azure AI Foundry model inference chat completions through `POST /models/chat/completions?api-version=...`
 - 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 AI Foundry model info health checks 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
+- Offline-first offering discovery from configured deployments
+- Deployment-name-preserving routing metadata 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
+- Shared OpenAI-compatible request and response mapping through `Legion::Extensions::Llm::Provider::OpenAICompatible`
+- Shared registry availability publishing through `Legion::Extensions::Llm::RegistryPublisher` when transport is available
+- Provider-owned fleet request handling through `Legion::Extensions::Llm::Fleet::ProviderResponder`
 
 ## Architecture
 
-```
+```text
 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
+|-- Provider              # Azure AI Foundry and Azure OpenAI hosted provider surface
+|   `-- Capabilities      # Capability predicates inferred from deployment metadata and model naming
+|-- Actor::FleetWorker    # Subscription actor for provider-owned fleet requests
+|-- Runners::FleetWorker  # Runner entrypoint that delegates to lex-llm ProviderResponder
+`-- VERSION
 ```
 
+`AzureFoundry.discover_instances` reads `extensions.llm.azure_foundry` settings and returns provider instance configs. The base Legion LLM runtime can use those configs to populate the provider registry and routing inventory; this gem does not write `legion-llm` registry state itself at require time.
+
 ## 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.rb` | Entry point, provider defaults, instance discovery, shared registry publisher |
+| `lib/legion/extensions/llm/azure_foundry/provider.rb` | Provider implementation with chat, stream, embed, health, readiness, model listing, and offering discovery |
+| `lib/legion/extensions/llm/azure_foundry/actors/fleet_worker.rb` | Subscription actor gated by ProviderResponder fleet settings |
+| `lib/legion/extensions/llm/azure_foundry/runners/fleet_worker.rb` | Fleet request runner that delegates execution to `ProviderResponder.call` |
 | `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`
+## Configuration
 
-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.
+Configured instances can be supplied through Legion settings under `extensions.llm.azure_foundry`. A top-level endpoint creates a `:settings` instance; entries under `instances` create named instances.
+
+```yaml
+extensions:
+  llm:
+    azure_foundry:
+      endpoint: https://example.services.ai.azure.com
+      api_key: env://AZURE_INFERENCE_CREDENTIAL
+      bearer_token: env://AZURE_FOUNDRY_BEARER_TOKEN
+      api_version: 2024-05-01-preview
+      surface: model_inference
+      deployments:
+        - deployment: gpt-4o-prod
+          model_family: openai
+          canonical_model_alias: gpt-4o
+          usage_type: inference
+        - deployment: embedding-prod
+          model_family: openai
+          canonical_model_alias: text-embedding-3-small
+          usage_type: embedding
+      instances:
+        prod:
+          endpoint: https://prod.services.ai.azure.com
+          api_key: env://AZURE_INFERENCE_CREDENTIAL
+          api_version: 2024-05-01-preview
+          surface: model_inference
+          deployments:
+            - deployment: gpt-4o-prod
+              model_family: openai
+              canonical_model_alias: gpt-4o
+              usage_type: inference
+          fleet:
+            enabled: true
+            respond_to_requests: true
+            capabilities:
+              - chat
+              - stream_chat
+              - embed
+```
 
-## API Contract
+The provider also supports direct configuration through `Legion::Extensions::Llm.configure` for tests and embedded use:
 
-The implementation follows Microsoft Learn REST documentation for Azure AI Foundry Models:
+```ruby
+Legion::Extensions::Llm.configure do |config|
+  config.azure_foundry_endpoint = ENV.fetch('AZURE_FOUNDRY_ENDPOINT')
+  config.azure_foundry_api_key = ENV['AZURE_INFERENCE_CREDENTIAL']
+  config.azure_foundry_bearer_token = ENV['AZURE_FOUNDRY_BEARER_TOKEN']
+  config.azure_foundry_api_version = '2024-05-01-preview'
+  config.azure_foundry_surface = :model_inference
+  config.azure_foundry_deployments = [
+    {
+      deployment: 'gpt-4o-prod',
+      model_family: :openai,
+      canonical_model_alias: 'gpt-4o',
+      usage_type: :inference
+    }
+  ]
+end
+```
 
-- Azure AI Foundry model inference endpoints use deployment names as the request `model`.
-- The model inference endpoint supports chat completions and embeddings.
-- The documented model-info endpoint is used only for explicit live health checks.
-- Azure deployment metadata is not assumed to reliably prove base model family or version, so routing metadata should be configured explicitly.
+Use `:openai_v1` when the endpoint should be treated as the OpenAI v1-compatible Azure route. The provider appends `/openai/v1` when the configured endpoint does not already include it.
 
-## Defaults
+## Default Settings
 
 ```ruby
 Legion::Extensions::Llm::AzureFoundry.default_settings
 # {
+#   enabled: true,
 #   provider_family: :azure_foundry,
-#   discovery: { enabled: true, live: false },
 #   instances: {
 #     default: {
-#       endpoint: "https://<resource>.services.ai.azure.com",
-#       api_version: "2024-05-01-preview",
-#       surface: :model_inference,
+#       endpoint: nil,
 #       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"
+#         api_key: nil,
+#         bearer_token: nil
+#       },
+#       provider: {
+#         api_version: "2024-05-01-preview",
+#         surface: nil,
+#         deployments: []
 #       },
-#       deployments: [],
-#       usage: { inference: true, embedding: true, token_counting: false },
-#       limits: { concurrency: 4 }
+#       usage: { inference: true, embedding: true, image: false },
+#       limits: { concurrency: 4 },
+#       fleet: {
+#         enabled: false,
+#         respond_to_requests: false,
+#         capabilities: [:chat, :stream_chat, :embed],
+#         lanes: [],
+#         concurrency: 4,
+#         queue_suffix: nil
+#       }
 #     }
 #   }
 # }
 ```
 
-## Configuration
-
-```ruby
-Legion::Extensions::Llm.configure do |config|
-  config.azure_foundry_endpoint = ENV.fetch("AZURE_FOUNDRY_ENDPOINT")
-  config.azure_foundry_api_key = ENV["AZURE_INFERENCE_CREDENTIAL"]
-  config.azure_foundry_bearer_token = ENV["AZURE_FOUNDRY_BEARER_TOKEN"]
-  config.azure_foundry_api_version = "2024-05-01-preview"
-  config.azure_foundry_surface = :model_inference
-  config.azure_foundry_deployments = [
-    {
-      deployment: "gpt-4o-prod",
-      model_family: :openai,
-      canonical_model_alias: "gpt-4o",
-      usage_type: :inference
-    },
-    {
-      deployment: "mistral-large-prod",
-      model_family: :mistral,
-      canonical_model_alias: "mistral-large",
-      usage_type: :inference
-    },
-    {
-      deployment: "embedding-prod",
-      model_family: :openai,
-      canonical_model_alias: "text-embedding-3-small",
-      usage_type: :embedding
-    }
-  ]
-end
-```
-
-Use `config.azure_foundry_surface = :openai_v1` when the target endpoint should be treated as the OpenAI v1-compatible Azure route. The provider appends `/openai/v1` when the configured endpoint does not already include it.
-
 ## Provider Methods
 
 ```ruby
 provider = Legion::Extensions::Llm::AzureFoundry.provider_class.new(Legion::Extensions::Llm.config)
 
 provider.discover_offerings(live: false)
-provider.offering_for(model: "gpt-4o-prod", model_family: :openai, canonical_model_alias: "gpt-4o")
+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")
-provider.count_tokens(messages, model: "gpt-4o-prod")
+provider.chat(messages: messages, model: 'gpt-4o-prod')
+provider.stream(messages: messages, model: 'gpt-4o-prod') { |chunk| puts chunk.content }
+provider.embed(text: ['hello'], model: 'embedding-prod')
+provider.count_tokens(messages: messages, model: 'gpt-4o-prod')
 ```
 
-`discover_offerings(live: false)` never calls Azure. It maps configured deployments into `Legion::Extensions::Llm::Routing::ModelOffering` values with `provider_family: :azure_foundry`.
+`discover_offerings(live: false)` does not call Azure. It maps configured deployments into `Legion::Extensions::Llm::Routing::ModelOffering` values with `provider_family: :azure_foundry`.
 
 `health(live: true)` calls the documented model-info endpoint for the configured model-inference surface. Keep `live: false` for startup paths and tests that must not require Azure.
 
 `count_tokens` returns a structured unsupported result by default because the Microsoft REST contract used here does not define a portable token-counting endpoint across Azure AI Foundry deployments.
 
+## Fleet Responder
+
+Provider instances can opt in to consuming Legion LLM fleet requests. The actor is enabled only when at least one discovered instance has `fleet.respond_to_requests: true`.
+
+Fleet execution is delegated to `Legion::Extensions::Llm::Fleet::ProviderResponder` from `lex-llm`; this provider supplies the provider family, provider class, discovered instances, and delivery metadata.
+
 ## Routing Metadata
 
 Azure deployments are aliases. A deployment name can hide provider, model, and version details, so this extension preserves the deployment name as `model` and treats `canonical_model_alias` and `model_family` as routing metadata.
@@ -163,3 +189,7 @@ Supported `model_family` values are intentionally open-ended symbols, including:
 - `:microsoft`
 
 When `model_family` or `canonical_model_alias` is missing, offerings include `requires_explicit_model_metadata: true`.
+
+## Failure Behavior
+
+Live discovery and health-check failures are reported with `handle_exception(e, level: :warn, handled: true, operation: ...)` before returning degraded metadata. Offline discovery, provider configuration, and fleet actor enablement should not require live Azure connectivity.

data/lex-llm-azure-foundry.gemspec

@@ -26,5 +26,6 @@ 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.3.0'
+  spec.add_dependency 'legion-transport', '>= 1.4.14'
+  spec.add_dependency 'lex-llm', '>= 0.4.3'
 end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+begin
+  require 'legion/extensions/actors/subscription'
+rescue LoadError => e
+  warn(e.message) if $VERBOSE
+end
+
+unless defined?(Legion::Extensions::Actors::Subscription)
+  raise LoadError, 'LegionIO actor runtime is required for Azure Foundry fleet worker'
+end
+
+require 'legion/extensions/llm/azure_foundry'
+require 'legion/extensions/llm/fleet/provider_responder'
+
+module Legion
+  module Extensions
+    module Llm
+      module AzureFoundry
+        module Actor
+          # Subscription actor for Azure Foundry fleet request consumption.
+          class FleetWorker < Legion::Extensions::Actors::Subscription
+            def runner_class
+              'Legion::Extensions::Llm::AzureFoundry::Runners::FleetWorker'
+            end
+
+            def runner_function
+              'handle_fleet_request'
+            end
+
+            def use_runner?
+              false
+            end
+
+            def enabled?
+              Legion::Extensions::Llm::Fleet::ProviderResponder.enabled_for?(AzureFoundry.discover_instances)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -18,6 +18,8 @@ module Legion
 
           class << self
             def slug = 'azure_foundry'
+            def default_transport = :http
+            def default_tier = :cloud
             def configuration_requirements = %i[azure_foundry_endpoint]
 
             def configuration_options
@@ -128,10 +130,10 @@ module Legion
           end
 
           def headers
-            {
+            identity_headers.merge({
               'api-key' => config.azure_foundry_api_key,
               'Authorization' => bearer_header
-            }.compact
+            }.compact)
           end
 
           def completion_url = path_for('chat/completions')
@@ -143,10 +145,10 @@ module Legion
 
           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
+            offerings = filter_offerings(allowed_offerings, **filters)
+            return offerings unless live
 
-            filter_offerings(offerings, **filters).map do |offering|
+            offerings.map do |offering|
               with_live_metadata(offering)
             rescue StandardError => e
               handle_exception(e, level: :warn, handled: true, operation: 'azure_foundry.discover_offerings')
@@ -197,25 +199,49 @@ module Legion
             models
           end
 
-          def chat(messages, model:, temperature: nil, max_tokens: nil, tools: {}, tool_prefs: nil, params: {}) # rubocop:disable Metrics/ParameterLists
+          def chat(
+            messages:,
+            model:,
+            **options
+          )
             log.info { "chat request model=#{model} messages=#{messages.size}" }
-            complete(messages, tools:, temperature:, model: model_info(model, max_tokens:), params:, tool_prefs:)
+            complete(messages, tools: options.fetch(:tools, {}), temperature: options[:temperature],
+                               model: model_info(model, max_tokens: options[:max_tokens]),
+                               params: options.fetch(:params, {}), tool_prefs: options[:tool_prefs])
           end
 
-          def stream(messages, model:, temperature: nil, max_tokens: nil, tools: {}, tool_prefs: nil, params: {}, &) # rubocop:disable Metrics/ParameterLists
+          def stream(
+            messages:,
+            model:,
+            **options,
+            &
+          )
             log.info { "stream request model=#{model} messages=#{messages.size}" }
-            complete(messages, tools:, temperature:, model: model_info(model, max_tokens:), params:, tool_prefs:, &)
+            complete(messages, tools: options.fetch(:tools, {}), temperature: options[:temperature],
+                               model: model_info(model, max_tokens: options[:max_tokens]),
+                               params: options.fetch(:params, {}), tool_prefs: options[:tool_prefs], &)
           end
 
-          def embed(text, model:, dimensions: nil, input_type: nil)
+          def embed(
+            text:,
+            model:,
+            **options
+          )
             log.info { "embed request model=#{model}" }
-            payload = render_embedding_payload(text, model: model_id(model), dimensions:)
-            payload[:input_type] = input_type if input_type
+            payload = Utils.deep_merge(
+              render_embedding_payload(text, model: model_id(model), dimensions: options[:dimensions]),
+              options.fetch(:params, {})
+            )
+            payload[:input_type] = options[:input_type] if options[:input_type]
             response = connection.post(embedding_url(model:), payload)
             parse_embedding_response(response, model: model_id(model), text:)
           end
 
-          def count_tokens(messages, model:, **)
+          def count_tokens(
+            messages:,
+            model:,
+            **_provider_options
+          )
             {
               provider_family: :azure_foundry,
               model: model_id(model),
@@ -276,6 +302,18 @@ module Legion
             self.class.normalize_deployments(config.azure_foundry_deployments)
           end
 
+          def allowed_offerings
+            configured_deployments.filter_map do |deployment|
+              offering = offering_from_config(deployment)
+              next unless offering
+
+              mid = offering.respond_to?(:model) ? offering.model : (offering[:model] || deployment[:model])
+              next unless model_allowed?(mid.to_s)
+
+              offering
+            end
+          end
+
           def offering_from_config(deployment)
             deployment_name = value_for(deployment, :deployment) || value_for(deployment, :model)
             return nil if deployment_name.to_s.empty?
@@ -295,8 +333,8 @@ module Legion
             Legion::Extensions::Llm::Routing::ModelOffering.new(
               provider_family: :azure_foundry,
               instance_id: instance_id,
-              transport: :http,
-              tier: :frontier,
+              transport: offering_transport,
+              tier: offering_tier,
               model: model,
               usage_type: usage_type.to_sym,
               capabilities: capabilities,

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/llm/fleet/provider_responder'
+require 'legion/extensions/llm/azure_foundry'
+
+module Legion
+  module Extensions
+    module Llm
+      module AzureFoundry
+        module Runners
+          # Runner entrypoint for Azure Foundry fleet request execution.
+          module FleetWorker
+            module_function
+
+            def handle_fleet_request(payload, delivery: nil, properties: nil)
+              Legion::Extensions::Llm::Fleet::ProviderResponder.call(
+                payload: payload,
+                provider_family: AzureFoundry::PROVIDER_FAMILY,
+                provider_class: AzureFoundry::Provider,
+                provider_instances: -> { AzureFoundry.discover_instances },
+                delivery: delivery,
+                properties: properties
+              )
+            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.2.0'
+        VERSION = '0.2.6'
       end
     end
   end

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

@@ -16,21 +16,33 @@ module Legion
         PROVIDER_FAMILY = :azure_foundry
 
         def self.default_settings
-          {
-            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: {}
-          }
+          ::Legion::Extensions::Llm.provider_settings(
+            family: PROVIDER_FAMILY,
+            instance: {
+              endpoint: nil,
+              tier: :frontier,
+              transport: :http,
+              credentials: {
+                api_key: nil,
+                bearer_token: nil
+              },
+              provider: {
+                api_version: Provider::DEFAULT_API_VERSION,
+                surface: nil,
+                deployments: []
+              },
+              usage: { inference: true, embedding: true, image: false },
+              limits: { concurrency: 4 },
+              fleet: {
+                enabled: false,
+                respond_to_requests: false,
+                capabilities: %i[chat stream_chat embed],
+                lanes: [],
+                concurrency: 4,
+                queue_suffix: nil
+              }
+            }
+          )
         end
 
         def self.provider_class
@@ -48,14 +60,15 @@ module Legion
           instances
         end
 
-        def self.discover_default_instance(instances)
+        def self.discover_default_instance(instances) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           cfg = CredentialSources.setting(:extensions, :llm, :azure_foundry)
           return unless cfg.is_a?(Hash)
 
-          endpoint = cfg[:endpoint] || cfg['endpoint']
+          endpoint = cfg[:endpoint] || cfg['endpoint'] || cfg[:base_url] || cfg['base_url'] || cfg[:api_base] ||
+                     cfg['api_base']
           return if endpoint.nil? || endpoint.to_s.strip.empty?
 
-          instances[:settings] = cfg.except(:instances, 'instances').merge(tier: :cloud)
+          instances[:settings] = normalize_instance_config(cfg).merge(tier: :cloud)
         end
 
         def self.discover_named_instances(instances)
@@ -68,21 +81,35 @@ module Legion
           named.each { |name, config| add_named_instance(instances, name, config) }
         end
 
-        def self.add_named_instance(instances, name, config)
+        def self.add_named_instance(instances, name, config) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           return unless config.is_a?(Hash)
 
-          endpoint = config[:endpoint] || config['endpoint']
+          endpoint = config[:endpoint] || config['endpoint'] || config[:base_url] || config['base_url'] ||
+                     config[:api_base] || config['api_base']
           return if endpoint.nil? || endpoint.to_s.strip.empty?
 
-          instances[name.to_sym] = config.merge(tier: :cloud)
+          instances[name.to_sym] = normalize_instance_config(config).merge(tier: :cloud)
         end
 
-        private_class_method :discover_default_instance, :discover_named_instances, :add_named_instance
+        def self.normalize_instance_config(config) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          normalized = config.to_h.transform_keys { |key| key.respond_to?(:to_sym) ? key.to_sym : key }
+          normalized[:azure_foundry_endpoint] ||= normalized.delete(:endpoint)
+          normalized[:azure_foundry_endpoint] ||= normalized.delete(:base_url)
+          normalized[:azure_foundry_endpoint] ||= normalized.delete(:api_base)
+          normalized[:azure_foundry_api_key] ||= normalized.delete(:api_key)
+          normalized[:azure_foundry_bearer_token] ||= normalized.delete(:bearer_token)
+          normalized[:azure_foundry_api_version] ||= normalized.delete(:api_version)
+          normalized[:azure_foundry_surface] ||= normalized.delete(:surface)
+          normalized[:azure_foundry_deployments] ||= normalized.delete(:deployments)
+          normalized.compact.except(:instances)
+        end
+
+        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)
+        Legion::Extensions::Llm::Configuration.register_provider_options(Provider.configuration_options) if
+          Legion::Extensions::Llm::Configuration.respond_to?(:register_provider_options)
       end
     end
   end
 end
-
-Legion::Extensions::Llm::AzureFoundry.register_discovered_instances

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-azure-foundry
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.6
 platform: ruby
 authors:
 - LegionIO
@@ -51,20 +51,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.3.14
+- !ruby/object:Gem::Dependency
+  name: legion-transport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.14
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.14
 - !ruby/object:Gem::Dependency
   name: lex-llm
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.4.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.4.3
 description: Azure AI Foundry and Azure OpenAI hosted provider integration for LegionIO
   LLM routing.
 email:
@@ -84,7 +98,9 @@ files:
 - README.md
 - lex-llm-azure-foundry.gemspec
 - lib/legion/extensions/llm/azure_foundry.rb
+- lib/legion/extensions/llm/azure_foundry/actors/fleet_worker.rb
 - lib/legion/extensions/llm/azure_foundry/provider.rb
+- lib/legion/extensions/llm/azure_foundry/runners/fleet_worker.rb
 - lib/legion/extensions/llm/azure_foundry/version.rb
 homepage: https://github.com/LegionIO/lex-llm-azure-foundry
 licenses: