lex-llm-azure-foundry 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 33f564df8dc0e10567cb8780f15976c66d399ca545a6303674bd67e11896e404
+  data.tar.gz: bd35a164c1adb9c8c1ed3eaa590dc97908b2c2bfca74d09e2784ae41349d0c24
+SHA512:
+  metadata.gz: 861eb2e467c3ef97123dd06705cd5eccbfb708573231e85cc171a10a8b7749bca5001cbe92e34eb5a8fb5a0a275277350f245a45daeba38b3efd843d8ae5c65b
+  data.tar.gz: a78aaace8611a9f72beb67f524d7e6c949f7c737698d77770280ab9d8bbee4305720ebed779d65e3df26971eb2ad2c8a457bd3b9640e5dc905e83b8a8136b593

data/.github/CODEOWNERS

@@ -0,0 +1,2 @@
+* @LegionIO/maintainers
+* @LegionIO/ai

data/.github/dependabot.yml

@@ -0,0 +1,18 @@
+version: 2
+updates:
+  - package-ecosystem: bundler
+    directory: /
+    schedule:
+      interval: weekly
+      day: monday
+    open-pull-requests-limit: 5
+    labels:
+      - "type:dependencies"
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: weekly
+      day: monday
+    open-pull-requests-limit: 5
+    labels:
+      - "type:dependencies"

data/.github/workflows/ci.yml

@@ -0,0 +1,16 @@
+name: CI
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  ci:
+    uses: LegionIO/.github/.github/workflows/ci.yml@main
+
+  release:
+    needs: ci
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    uses: LegionIO/.github/.github/workflows/release.yml@main
+    secrets:
+      rubygems-api-key: ${{ secrets.RUBYGEMS_API_KEY }}

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/coverage/
+/pkg/
+/tmp/
+Gemfile.lock
+*.gem
+
+.rspec_status*
+.env
+.claude
+AGENTS.md
+CLAUDE.md

data/.rubocop.yml

@@ -0,0 +1,18 @@
+plugins:
+  - rubocop-performance
+  - rubocop-rake
+  - rubocop-rspec
+
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 3.4
+  SuggestExtensions: false
+
+Metrics/BlockLength:
+  Exclude:
+    - "*.gemspec"
+    - spec/**/*
+Metrics/MethodLength:
+  Enabled: false
+RSpec/MultipleExpectations:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+## 0.1.0 - 2026-04-28
+
+- Initial Legion LLM Azure AI Foundry provider extension scaffold.
+- Add Azure AI Foundry model inference and Azure OpenAI v1-compatible endpoint mapping.
+- Add offline deployment-based offering discovery with explicit model-family and canonical-alias metadata.
+- Add chat, streaming, embeddings, health, and token-count placeholder provider methods without requiring live Azure access.

data/Gemfile

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+group :test do
+  llm_base_path = ENV.fetch('LEX_LLM_PATH', File.expand_path('../lex-llm', __dir__))
+  gem 'lex-llm', path: llm_base_path if File.directory?(llm_base_path)
+end
+
+gemspec
+
+group :development do
+  gem 'bundler', '>= 2.0'
+  gem 'rake', '>= 13.0'
+  gem 'rspec', '~> 3.12'
+  gem 'rubocop', '>= 1.0'
+  gem 'rubocop-performance'
+  gem 'rubocop-rake', '>= 0.6'
+  gem 'rubocop-rspec'
+end

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Carmine Paolino
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,125 @@
+# lex-llm-azure-foundry
+
+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.
+
+Load it with `require 'legion/extensions/llm/azure_foundry'`.
+
+## What It Provides
+
+- `Legion::Extensions::Llm::Provider` registration as `: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 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
+
+## API Contract
+
+The implementation follows Microsoft Learn REST documentation for Azure AI Foundry Models:
+
+- 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.
+
+## Defaults
+
+```ruby
+Legion::Extensions::Llm::AzureFoundry.default_settings
+# {
+#   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,
+#       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 }
+#     }
+#   }
+# }
+```
+
+## 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.health(live: false)
+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")
+```
+
+`discover_offerings(live: false)` never calls 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.
+
+## 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.
+
+Supported `model_family` values are intentionally open-ended symbols, including:
+
+- `:openai`
+- `:mistral`
+- `:meta`
+- `:xai`
+- `:anthropic`
+- `:microsoft`
+
+When `model_family` or `canonical_model_alias` is missing, offerings include `requires_explicit_model_metadata: true`.

data/lex-llm-azure-foundry.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/llm/azure_foundry/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-llm-azure-foundry'
+  spec.version       = Legion::Extensions::Llm::AzureFoundry::VERSION
+  spec.authors       = ['LegionIO']
+  spec.email         = ['matthewdiverson@gmail.com']
+  spec.summary       = 'LegionIO LLM Azure AI Foundry provider extension'
+  spec.description   = 'Azure AI Foundry and Azure OpenAI hosted provider integration for LegionIO LLM routing.'
+  spec.homepage      = 'https://github.com/LegionIO/lex-llm-azure-foundry'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = '>= 3.4'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['documentation_uri'] = spec.homepage
+  spec.metadata['changelog_uri'] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+  spec.metadata['bug_tracker_uri'] = "#{spec.homepage}/issues"
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = `git ls-files -z`.split("\x0").reject { |file| file.match(%r{^(spec|test|features|tmp|coverage)/}) }
+  spec.require_paths = ['lib']
+
+  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'
+end

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

@@ -0,0 +1,357 @@
+# frozen_string_literal: true
+
+require 'legion/json'
+require 'legion/logging'
+require 'legion/settings'
+require 'legion/extensions/llm'
+
+module Legion
+  module Extensions
+    module Llm
+      module AzureFoundry
+        # Azure AI Foundry and Azure OpenAI hosted provider surface.
+        class Provider < Legion::Extensions::Llm::Provider # rubocop:disable Metrics/ClassLength
+          include Legion::Extensions::Llm::Provider::OpenAICompatible
+
+          DEFAULT_API_VERSION = '2024-05-01-preview'
+          MODEL_INFERENCE_SURFACE = :model_inference
+          OPENAI_V1_SURFACE = :openai_v1
+
+          class << self
+            def slug = 'azure_foundry'
+            def configuration_requirements = %i[azure_foundry_endpoint]
+
+            def configuration_options
+              %i[
+                azure_foundry_endpoint
+                azure_foundry_api_key
+                azure_foundry_bearer_token
+                azure_foundry_api_version
+                azure_foundry_surface
+                azure_foundry_deployments
+              ]
+            end
+
+            def capabilities = Capabilities
+
+            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
+            end
+
+            def deployment_config(model_id, config:)
+              deployments = config&.azure_foundry_deployments
+              entries = normalize_deployments(deployments)
+              entries.find do |entry|
+                [value_for(entry, :deployment), value_for(entry, :model), value_for(entry, :canonical_model_alias)]
+                  .compact.map(&:to_s).include?(model_id.to_s)
+              end
+            end
+
+            def normalize_deployments(deployments)
+              case deployments
+              when Hash
+                deployments.map do |name, metadata|
+                  value = metadata.to_h
+                  value[:deployment] ||= name
+                  value
+                end
+              else
+                Array(deployments).map { |deployment| normalize_deployment_entry(deployment) }
+              end
+            end
+
+            private
+
+            def normalize_deployment_entry(deployment)
+              deployment.is_a?(Hash) ? deployment.dup : { deployment: deployment.to_s }
+            end
+
+            def value_for(hash, key)
+              return nil unless hash.respond_to?(:key?)
+
+              hash[key] || hash[key.to_s]
+            end
+          end
+
+          # Capability predicates inferred from deployment metadata and model naming.
+          module Capabilities
+            module_function
+
+            def chat?(model) = !embeddings?(model)
+            def streaming?(model) = chat?(model)
+            def functions?(model) = chat?(model)
+            def vision?(model) = chat?(model) && model_id(model).match?(/(gpt-4|gpt-5|llava|vision|phi-3.5)/i)
+            def embeddings?(model) = usage_type(model) == :embedding || model_id(model).match?(/embed/i)
+
+            def critical_capabilities_for(model)
+              [
+                ('streaming' if streaming?(model)),
+                ('function_calling' if functions?(model)),
+                ('vision' if vision?(model)),
+                ('embeddings' if embeddings?(model))
+              ].compact
+            end
+
+            def model_id(model)
+              return hash_model_id(model) if model.is_a?(Hash)
+
+              model.respond_to?(:id) ? model.id.to_s : model.to_s
+            end
+
+            def hash_model_id(model)
+              %i[canonical_model_alias model deployment].each do |key|
+                value = model[key] || model[key.to_s]
+                return value.to_s if value
+              end
+            end
+
+            def usage_type(model)
+              return nil unless model.is_a?(Hash)
+
+              value = model[:usage_type] || model['usage_type'] || model[:type] || model['type']
+              value&.to_sym
+            end
+          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')
+            return endpoint.delete_suffix('/models') if surface == MODEL_INFERENCE_SURFACE
+
+            endpoint
+          end
+
+          def headers
+            {
+              'api-key' => config.azure_foundry_api_key,
+              'Authorization' => bearer_header
+            }.compact
+          end
+
+          def completion_url = path_for('chat/completions')
+          def chat_url = completion_url
+          def stream_url = completion_url
+          def models_url = path_for('info')
+          def embedding_url(**) = path_for('embeddings')
+          def health_url = models_url
+
+          def discover_offerings(live: false, **filters)
+            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
+              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
+                           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)
+
+            build_offering(
+              model: model_id,
+              instance_id: 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),
+              metadata: metadata.merge(deployment_metadata(deployment))
+            )
+          end
+
+          def health(live: false)
+            baseline = {
+              provider: :azure_foundry,
+              configured: configured?,
+              ready: configured?,
+              live: live,
+              api_base: api_base,
+              surface: surface
+            }
+            return baseline.merge(checked: false) unless live
+
+            response = connection.get(health_url)
+            baseline.merge(checked: true, model_info: response.body)
+          rescue StandardError => e
+            baseline.merge(checked: true, ready: false, error: e.class.name, message: e.message)
+          end
+
+          def readiness(live: false)
+            health(live: live).merge(local: false, remote: true, endpoints: endpoint_manifest)
+          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
+          end
+
+          def chat(messages, model:, temperature: nil, max_tokens: nil, tools: {}, tool_prefs: nil, params: {}) # rubocop:disable Metrics/ParameterLists
+            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
+            complete(messages, tools:, temperature:, model: model_info(model, max_tokens:), params:, tool_prefs:, &)
+          end
+
+          def embed(text, model:, dimensions: nil, input_type: nil)
+            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)
+            parse_embedding_response(response, model: model_id(model), text:)
+          end
+
+          def count_tokens(messages, model:, **)
+            {
+              provider_family: :azure_foundry,
+              model: model_id(model),
+              supported: false,
+              reason: 'Azure AI Foundry REST docs do not define a portable token-counting endpoint for this surface.',
+              estimated_input_characters: messages.sum { |message| message.content.to_s.length }
+            }
+          end
+
+          private
+
+          def surface
+            (config.azure_foundry_surface || MODEL_INFERENCE_SURFACE).to_sym
+          end
+
+          def api_version
+            config.azure_foundry_api_version || DEFAULT_API_VERSION
+          end
+
+          def path_for(path)
+            prefix = surface == MODEL_INFERENCE_SURFACE ? '/models' : ''
+            suffix = surface == MODEL_INFERENCE_SURFACE ? "?api-version=#{api_version}" : ''
+            "#{prefix}/#{path}#{suffix}"
+          end
+
+          def bearer_header
+            token = config.azure_foundry_bearer_token
+            token ? "Bearer #{token}" : nil
+          end
+
+          def configured_deployments
+            self.class.normalize_deployments(config.azure_foundry_deployments)
+          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_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
+            )
+          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)
+            Legion::Extensions::Llm::Routing::ModelOffering.new(
+              provider_family: :azure_foundry,
+              instance_id: instance_id,
+              transport: :http,
+              tier: :frontier,
+              model: model,
+              usage_type: usage_type.to_sym,
+              capabilities: capabilities,
+              metadata: metadata.merge(
+                model_family: model_family,
+                canonical_model_alias: canonical_model_alias,
+                requires_explicit_model_metadata: canonical_model_alias.nil? || model_family.nil?
+              ).compact
+            )
+          end
+
+          def with_live_metadata(offering)
+            response = connection.get(models_url)
+            metadata = offering.metadata.merge(model_info: response.body)
+            with_health(offering, ready: true, checked: true, metadata:)
+          end
+
+          def with_health(offering, ready:, checked:, error: nil, metadata: offering.metadata)
+            health = { ready: ready, checked: checked }
+            health = health.merge(error: error.class.name, message: error.message) if error
+
+            Legion::Extensions::Llm::Routing::ModelOffering.new(offering.to_h.merge(health:, metadata:))
+          end
+
+          def filter_offerings(offerings, model_family: nil, usage_type: nil, **)
+            offerings.select do |offering|
+              family_matches = model_family.nil? || offering.metadata[:model_family] == model_family.to_sym
+              usage_matches = usage_type.nil? || offering.usage_type == usage_type.to_sym
+              family_matches && usage_matches
+            end
+          end
+
+          def deployment_metadata(deployment)
+            return {} unless deployment
+
+            deployment.to_h.transform_keys(&:to_sym).except(:deployment, :model_family, :usage_type)
+          end
+
+          def capabilities_for(model, usage_type)
+            return %i[embedding] if usage_type.to_sym == :embedding
+
+            Capabilities.critical_capabilities_for(model).map(&:to_sym)
+          end
+
+          def usage_type_for(model)
+            Capabilities.embeddings?(model) ? :embedding : :inference
+          end
+
+          def normalize_family(value)
+            value&.to_sym
+          end
+
+          def infer_model_family(model)
+            id = model.to_s.downcase
+            return :openai if id.match?(/gpt|o\d|text-embedding|dall-e/)
+            return :mistral if id.include?('mistral')
+            return :meta if id.match?(/llama|meta/)
+            return :xai if id.match?(/grok|xai/)
+            return :anthropic if id.include?('claude')
+            return :microsoft if id.match?(/phi|microsoft/)
+
+            nil
+          end
+
+          def value_for(hash, key)
+            return nil unless hash.respond_to?(:key?)
+
+            hash[key] || hash[key.to_s]
+          end
+
+          def model_id(model)
+            self.class.resolve_model_id(model.respond_to?(:id) ? model.id : model, config:)
+          end
+
+          def model_info(model, max_tokens: nil)
+            return model if model.respond_to?(:id) && max_tokens.nil?
+
+            Legion::Extensions::Llm::Model::Info.new(id: model_id(model), provider: :azure_foundry,
+                                                     max_output_tokens: max_tokens)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Llm
+      module AzureFoundry
+        VERSION = '0.1.0'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/llm'
+require 'legion/extensions/llm/azure_foundry/provider'
+require 'legion/extensions/llm/azure_foundry/version'
+
+module Legion
+  module Extensions
+    module Llm
+      # Azure AI Foundry provider extension namespace.
+      module AzureFoundry
+        extend ::Legion::Extensions::Core if ::Legion::Extensions.const_defined?(:Core, false)
+
+        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 }
+            }
+          )
+        end
+
+        def self.provider_class
+          Provider
+        end
+      end
+    end
+  end
+end
+
+Legion::Extensions::Llm::Provider.register(Legion::Extensions::Llm::AzureFoundry::PROVIDER_FAMILY,
+                                           Legion::Extensions::Llm::AzureFoundry::Provider)

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: lex-llm-azure-foundry
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- LegionIO
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: legion-json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+- !ruby/object:Gem::Dependency
+  name: legion-logging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+- !ruby/object:Gem::Dependency
+  name: legion-settings
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.14
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.14
+- !ruby/object:Gem::Dependency
+  name: lex-llm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.4
+description: Azure AI Foundry and Azure OpenAI hosted provider integration for LegionIO
+  LLM routing.
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/CODEOWNERS"
+- ".github/dependabot.yml"
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- ".rubocop.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- 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/version.rb
+homepage: https://github.com/LegionIO/lex-llm-azure-foundry
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-llm-azure-foundry
+  source_code_uri: https://github.com/LegionIO/lex-llm-azure-foundry
+  documentation_uri: https://github.com/LegionIO/lex-llm-azure-foundry
+  changelog_uri: https://github.com/LegionIO/lex-llm-azure-foundry/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/LegionIO/lex-llm-azure-foundry/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: LegionIO LLM Azure AI Foundry provider extension
+test_files: []