lex-llm-azure-foundry 0.3.4 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4bd55b677c93605664cd0865b329ecb256da01604c0d4e518f0fc4f60aa881b1
-  data.tar.gz: 59b84b52669fcb74740f563acc88e05b12e24e93765354f0b0f306d21ce9c4d9
+  metadata.gz: 49e5d8dc9a03ec7e353324aaf22050bf23a28ff085da22a8f779c7b01b28ffe0
+  data.tar.gz: 3c8c342a9bc24b2133a2060f9cc9dc9a9743d4d69bda1205e26db02f6d5a4f59
 SHA512:
-  metadata.gz: c5171449f55eb43c93f88ece8a3e2db532a51be1176d29c0769d926b10add693296ca78002360f5525ee5412b7ec4b43b40e96a24a5255aca256a9cca511567e
-  data.tar.gz: e804a59536425ff887d8b0d6787c801ed78280e239634c7be0749a513d366b17db5a9be12f58a548b3760e6f67148ba577da345ee99864089f0902da498d03fe
+  metadata.gz: ba398b8cdb7dcd17fa6138c9edccc482b66abb201c8ce198d4373d83ced0de5f8c1c756be4b55ec3b3a64921278db4d3b6673d146a77ed2121d6e7317622be79
+  data.tar.gz: d1c2877ae02270b74dba8be1daa23c9c676070c4d705194fa35933d31206d3c9bd5eccb0d2837c80ffe2fe278153766f0865d1e53d077cd4b9e84ce67c5fdef0

data/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## [0.3.5] - 2026-08-19
+
+### Changed
+- **Write-time SSOT lane weights** — Build Azure deployment drafts with the shared
+  four-component weight pair using the deployment name as the provider-native
+  offering identity, and reconcile weight-only changes atomically on the existing
+  discovery cadence. Initial/recovery activation now rebuilds from current settings,
+  removal wins readiness races, and dormant configured weights log once per absence
+  period without any Settings lifecycle callback.
+- **Callable-path system conformance** — Capture the rendered Azure/OpenAI-compatible
+  HTTP payload and verify a folded leading system message remains in the dialect-native
+  `role: system` message position.
+- **Dependency floor** — Raise `lex-llm` to `>= 0.7.6` for `WeightSchema`,
+  `WeightReconciler`, and the immutable record weight pair. The `legion-settings`
+  dependency and provider/operator workflow are unchanged.
+
+### Fixed
+- **Malformed-weight startup cleanup** — Validate and build weighted offering
+  drafts before constructing or claiming any callable scope, so invalid weight
+  values cannot leave an orphaned initializing Registry publication. A later
+  corrected discovery pass claims and activates the instance normally without
+  requiring a restart or operator cleanup.
+- **Complete offering replacement comparison** — Ordinary discovery now compares
+  every authoritative `OfferingDraft` field while ignoring only evidence
+  observation timestamps. Deployment order does not churn, duplicate counts stay
+  significant, and native-key, evidence, quota, metadata, publication-source,
+  tier, or weight drift advances the Registry snapshot exactly once.
+
 ## [0.3.4] - 2026-08-18
 
 ### Fixed

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.4.2'
   spec.add_dependency 'legion-transport', '>= 1.4.14'
-  spec.add_dependency 'lex-llm', '>= 0.7.1'
+  spec.add_dependency 'lex-llm', '>= 0.7.6'
 end

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

@@ -11,6 +11,7 @@ require 'legion/extensions/llm/inventory/records'
 require 'legion/extensions/llm/inventory/evidence'
 require 'legion/extensions/llm/inventory/probe_coordinator'
 require 'legion/extensions/llm/inventory/scoped_refresher'
+require 'legion/extensions/llm/inventory/weight_reconciler'
 require 'legion/extensions/llm/routing/provider_outcome'
 require 'legion/extensions/llm/taxonomies'
 require 'legion/extensions/llm/capabilities'
@@ -257,18 +258,34 @@ module Legion
 
               Legion::Extensions::Llm::Inventory::OfferingDraft.new(
                 provider_native_key: deployment_name, model: model_id, tier: tier,
+                **offering_evidence_fields(deployment: deployment, instance_cfg: instance_cfg, embed: embed),
+                quota_domains: build_quota_domains(deployment_name: deployment_name),
+                metadata: build_offering_metadata(deployment: deployment, deployment_name: deployment_name,
+                                                  instance_key: instance_key).freeze,
+                publication_source: :provider_static_catalog,
+                **weight_fields(instance_key: instance_key, deployment_name: deployment_name,
+                                model_id: model_id, tier: tier)
+              )
+            end
+
+            def weight_fields(instance_key:, deployment_name:, model_id:, tier:)
+              inputs = Legion::Extensions::Llm::Inventory::WeightSchema.weight_inputs(
+                settings: Legion::Settings, instance_key: instance_key,
+                provider_native_key: deployment_name, model: model_id, tier: tier
+              )
+              { weight_inputs: inputs, base_weight: Legion::Extensions::Llm::Inventory::WeightSchema.base_weight(inputs) }
+            end
+
+            def offering_evidence_fields(deployment:, instance_cfg:, embed:)
+              {
                 operation_evidence: build_operation_evidence(embed_supported: embed),
                 capability_evidence: build_capability_evidence(deployment: deployment, embed_supported: embed),
                 context_evidence: build_context_evidence(deployment: deployment, instance_cfg: instance_cfg),
                 max_output_evidence: build_max_output_evidence(deployment: deployment, instance_cfg: instance_cfg),
                 embedding_dimensions_evidence: absent_value_evidence,
                 model_revision_evidence: absent_value_evidence,
-                tokenizer_evidence: absent_value_evidence,
-                quota_domains: build_quota_domains(deployment_name: deployment_name),
-                metadata: build_offering_metadata(deployment: deployment, deployment_name: deployment_name,
-                                                  instance_key: instance_key).freeze,
-                publication_source: :provider_static_catalog
-              )
+                tokenizer_evidence: absent_value_evidence
+              }
             end
 
             def build_context_evidence(deployment:, instance_cfg:)
@@ -311,59 +328,47 @@ module Legion
             end
           end
 
-          # Offerings change detection. Time.now observed_at stamps in the
-          # evidence poison Data#==, so a rebuilt-but-unchanged catalog would
-          # otherwise replace the snapshot (and bump the sequence) every tick.
-          # Compare identity/status fields only.
+          # Complete OfferingDraft comparison. Evidence observation timestamps
+          # are telemetry-only; every other draft and evidence field remains
+          # authoritative. Catalog order is set-like and duplicate counts remain
+          # significant.
           module OfferingComparisonHelpers
+            SCALAR_EVIDENCE_FIELDS = %i[
+              context_evidence max_output_evidence embedding_dimensions_evidence
+              model_revision_evidence tokenizer_evidence
+            ].freeze
+
             private
 
             def offerings_changed?(previous:, current:)
-              return true unless previous.size == current.size
-
-              current.any? do |draft|
-                previous.none? { |candidate| drafts_stable?(candidate, draft) }
-              end
+              offerings_contract(previous) != offerings_contract(current)
             end
 
-            def drafts_stable?(candidate, draft)
-              basic_fields_stable?(candidate, draft) &&
-                evidence_maps_stable?(candidate.operation_evidence, draft.operation_evidence) &&
-                evidence_maps_stable?(candidate.capability_evidence, draft.capability_evidence) &&
-                value_fields_stable?(candidate, draft) &&
-                candidate.quota_domains == draft.quota_domains &&
-                candidate.metadata == draft.metadata
-            end
-
-            def basic_fields_stable?(candidate, draft)
-              candidate.model == draft.model &&
-                candidate.tier == draft.tier &&
-                evidence_key_set_stable?(candidate.operation_evidence, draft.operation_evidence) &&
-                evidence_key_set_stable?(candidate.capability_evidence, draft.capability_evidence)
-            end
-
-            def evidence_key_set_stable?(previous_map, current_map)
-              previous_map.keys.sort == current_map.keys.sort
+            def offerings_contract(offerings)
+              contracts = offerings.map { |draft| stable_offering_contract(draft) }
+              grouped = contracts.group_by do |contract|
+                [contract.fetch(:provider_native_key), contract.fetch(:model)]
+              end
+              grouped.sort_by { |identity, _| identity.map { |value| value.to_s.b } }
+                     .to_h.transform_values(&:tally)
             end
 
-            def evidence_maps_stable?(previous_map, current_map)
-              previous_map.all? do |key, evidence|
-                other = current_map[key]
-                other&.status == evidence.status && other&.source == evidence.source
+            def stable_offering_contract(draft)
+              contract = draft.to_h
+              contract[:operation_evidence] = stable_evidence_map(contract.fetch(:operation_evidence))
+              contract[:capability_evidence] = stable_evidence_map(contract.fetch(:capability_evidence))
+              SCALAR_EVIDENCE_FIELDS.each do |field|
+                contract[field] = stable_evidence(contract.fetch(field))
               end
+              contract
             end
 
-            def value_fields_stable?(candidate, draft)
-              values_stable?(candidate.context_evidence, draft.context_evidence) &&
-                values_stable?(candidate.max_output_evidence, draft.max_output_evidence) &&
-                values_stable?(candidate.embedding_dimensions_evidence, draft.embedding_dimensions_evidence) &&
-                values_stable?(candidate.model_revision_evidence, draft.model_revision_evidence)
+            def stable_evidence_map(evidence_by_key)
+              evidence_by_key.transform_values { |evidence| stable_evidence(evidence) }
             end
 
-            def values_stable?(previous_value, current_value)
-              previous_value.status == current_value.status &&
-                previous_value.value == current_value.value &&
-                previous_value.source == current_value.source
+            def stable_evidence(evidence)
+              evidence.to_h.except(:observed_at)
             end
           end
 
@@ -460,7 +465,7 @@ module Legion
             end
 
             def handle_reactive_probe(instance_id:, request:)
-              state = @instance_states && @instance_states[instance_id]
+              state = tracked_instance_state(instance_id)
               return unless state
 
               coordinator = state[:probe_coordinator]
@@ -481,6 +486,12 @@ module Legion
                                   instance_id: instance_id)
             end
 
+            def tracked_instance_state(instance_id)
+              return unless @instance_states
+
+              state_mutex.synchronize { @instance_states[instance_id] }
+            end
+
             def finish_probe_safely(coordinator:, request: nil)
               args = request ? { request: request } : {}
               coordinator&.finish_probe(**args)
@@ -528,17 +539,29 @@ module Legion
             def remove_all_instances
               return unless @instance_states
 
-              @instance_states.each do |instance_id, state|
-                publisher.remove_instance(
-                  instance_id: instance_id, publisher_token: state[:publisher_token],
-                  physical_id: state[:instance_key].physical_id
-                )
-                clear_instance_health(config_name: state[:name])
+              drain_instance_states.each do |instance_id, state|
+                remove_published_instance(instance_id: instance_id, state: state)
               rescue StandardError => e
                 handle_exception(e, level: :warn, operation: 'azure_foundry.actor.remove_instance',
                                     instance_id: instance_id)
               end
-              @instance_states.clear
+            end
+
+            def drain_instance_states
+              state_mutex.synchronize do
+                tracked = @instance_states.each_pair.map { |instance_id, state| [instance_id, state] }
+                @instance_states.clear
+                dormant_weight_tracker.clear!
+                tracked
+              end
+            end
+
+            def remove_published_instance(instance_id:, state:)
+              publisher.remove_instance(
+                instance_id: instance_id, publisher_token: state[:publisher_token],
+                physical_id: state[:instance_key].physical_id
+              )
+              clear_instance_health(config_name: state[:name])
             end
           end
 
@@ -562,12 +585,15 @@ module Legion
                 # enable_*) by. The derived endpoint id is the secondary
                 # physical field only.
                 instance_id = name.to_s
-                next if @instance_states.key?(instance_id)
+                next if state_mutex.synchronize { @instance_states.key?(instance_id) }
 
                 physical_id = derive_physical_id(instance_cfg: instance_cfg)
-                @instance_states[instance_id] = build_instance_context(
+                state = build_instance_context(
                   name: name, instance_id: instance_id, physical_id: physical_id, instance_cfg: instance_cfg
                 )
+                Legion::Extensions::Llm::Inventory::WeightReconciler.track_initializing!(
+                  states: @instance_states, state_key: instance_id, state: state, mutex: state_mutex
+                )
               rescue StandardError => e
                 handle_exception(e, level: :warn, operation: 'azure_foundry.actor.claim_instance',
                                     instance_name: name.to_s)
@@ -576,11 +602,13 @@ module Legion
 
             def release_removed_instances(discovered)
               discovered_names = discovered.keys.map(&:to_s)
-              (@instance_states.keys - discovered_names).each { |instance_id| remove_instance_state(instance_id) }
+              existing_names = state_mutex.synchronize { @instance_states.keys }
+              (existing_names - discovered_names).each { |instance_id| remove_instance_state(instance_id) }
             end
 
             def build_instance_context(name:, instance_id:, physical_id:, instance_cfg:)
               instance_key = build_instance_key(instance_id: instance_id, physical_id: physical_id)
+              offerings = discover_offerings_for_instance(instance_cfg: instance_cfg, instance_key: instance_key)
               callable = Legion::Extensions::Llm::AzureFoundry::Actor::AzureFoundryCallable.new(
                 instance_cfg: instance_cfg, logger: log
               )
@@ -594,7 +622,7 @@ module Legion
                 name: name, instance_key: instance_key, instance_cfg: instance_cfg,
                 callable: callable, probe_coordinator: probe_coordinator,
                 publisher_token: publisher_token, sequence: 0, last_probe_outcome: nil,
-                offerings: discover_offerings_for_instance(instance_cfg: instance_cfg, instance_key: instance_key)
+                offerings: offerings
               }
             end
 
@@ -605,7 +633,7 @@ module Legion
             end
 
             def remove_instance_state(instance_id)
-              state = @instance_states.delete(instance_id)
+              state = state_mutex.synchronize { @instance_states.delete(instance_id) }
               return unless state
 
               publisher.remove_instance(
@@ -619,48 +647,54 @@ module Legion
             end
           end
 
-          # Periodic refresh helpers — reconcile configured instances, recover
-          # instances still :initializing, diff offerings, drive cadence probes.
-          module RefreshHelpers
+          # Weight publication adapters bind Azure Foundry's existing publisher
+          # kwargs and stable comparison to the shared atomic reconciler.
+          module WeightPublicationHelpers
             private
 
-            def tick_refresh
-              reconcile_configured_instances
-              @instance_states.each do |instance_id, state|
-                refresh_instance(instance_id: instance_id, state: state)
-              rescue StandardError => e
-                handle_exception(e, level: :warn, operation: 'azure_foundry.actor.refresh_instance',
-                                    instance_id: instance_id)
-              end
+            def refresh_cached_offerings(instance_id:, state:)
+              offerings = discover_offerings_for_instance(
+                instance_cfg: state[:instance_cfg], instance_key: state[:instance_key]
+              )
+              commit_weight_snapshot(instance_id: instance_id, state: state, offerings: offerings)
+            end
+
+            def commit_weight_snapshot(instance_id:, state:, offerings:)
+              Legion::Extensions::Llm::Inventory::WeightReconciler.commit_if_changed!(
+                settings: Legion::Settings,
+                instance_id: instance_id,
+                state: state,
+                discovered_offerings: offerings,
+                mutex: state_mutex,
+                equivalent: lambda do |previous, current|
+                  !offerings_changed?(previous: previous, current: current)
+                end,
+                replace: method(:replace_weight_snapshot)
+              )
             end
 
-            # Re-scans configured instances every tick so instances configured
-            # after boot appear without a restart, and removed instances are
-            # released from the registry.
-            def reconcile_configured_instances
-              discovered = configured_instances
-              claim_new_instances(discovered)
-              release_removed_instances(discovered)
+            def replace_weight_snapshot(instance_id:, state:, offerings:, sequence:)
+              publisher.replace_instance_snapshot(
+                instance_id: instance_id, publisher_token: state[:publisher_token],
+                offerings: offerings, sequence: sequence,
+                physical_id: state[:instance_key].physical_id
+              )
             end
 
-            def refresh_instance(instance_id:, state:)
-              status = publisher.snapshot.publication_status(instance_key: state[:instance_key])
-              return log.debug { "[azure_foundry] no publication status for #{instance_id}; skipping refresh" } if
-                status.nil?
-
-              if status.state == :initializing
-                run_initialization_probe(instance_id: instance_id, state: state)
-              else
-                refresh_activated_instance(instance_id: instance_id, state: state)
-              end
+            def activate_weight_snapshot(instance_id:, state:, offerings:, sequence:, probe_token:)
+              publisher.activate_instance_snapshot(
+                instance_id: instance_id, publisher_token: state[:publisher_token],
+                offerings: offerings, sequence: sequence, probe_token: probe_token,
+                physical_id: state[:instance_key].physical_id
+              )
             end
+          end
+
+          # Initial and recovery readiness share the tracked-state activation
+          # gate, so removal wins without resurrecting an instance.
+          module InitialReadinessHelpers
+            private
 
-            # D4: an instance whose initial readiness failed stays :initializing.
-            # activate_instance_snapshot is the only transition legal from
-            # :initializing, so a later passing probe re-activates the claim
-            # (fresh probe token, current offerings, next sequence) instead of
-            # calling replace/readiness_succeeded, which would raise
-            # InvalidTransitionError.
             def run_initialization_probe(instance_id:, state:)
               coordinator = state[:probe_coordinator]
               return unless coordinator.begin_probe
@@ -683,7 +717,7 @@ module Legion
 
             def apply_initial_readiness(instance_id:, state:, probe_token:, readiness:)
               if readiness.ready?
-                activate_after_readiness(instance_id: instance_id, state: state, probe_token: probe_token)
+                activate_after_readiness?(instance_id: instance_id, state: state, probe_token: probe_token)
               else
                 report_initial_failure(
                   instance_id: instance_id, state: state, probe_token: probe_token, reason: readiness.reason
@@ -691,19 +725,27 @@ module Legion
               end
             end
 
-            def activate_after_readiness(instance_id:, state:, probe_token:)
-              state[:sequence] += 1
-              state[:last_probe_outcome] = :success
-              publisher.activate_instance_snapshot(
-                instance_id: instance_id, publisher_token: state[:publisher_token],
-                offerings: state[:offerings], sequence: state[:sequence], probe_token: probe_token,
-                physical_id: state[:instance_key].physical_id
+            def activate_after_readiness?(instance_id:, state:, probe_token:)
+              activated = Legion::Extensions::Llm::Inventory::WeightReconciler.activate_tracked!(
+                settings: Legion::Settings,
+                instance_id: instance_id,
+                state_key: instance_id,
+                state: state,
+                states: @instance_states,
+                mutex: state_mutex,
+                probe_token: probe_token,
+                activate: method(:activate_weight_snapshot),
+                activation_sequence: ->(tracked) { tracked.fetch(:sequence) + 1 }
               )
+              return false unless activated
+
+              state[:last_probe_outcome] = :success
               write_instance_health(
                 config_name: state[:name], available: true, reason: 'startup readiness succeeded',
                 probe_outcome: :success, source: :startup_readiness,
                 capabilities: instance_capabilities(state[:offerings])
               )
+              true
             end
 
             def report_initial_failure(instance_id:, state:, probe_token:, reason:)
@@ -717,33 +759,77 @@ module Legion
                 probe_outcome: :failure, source: :startup_readiness
               )
             end
+          end
+
+          # Periodic refresh helpers — reconcile configured instances, recover
+          # instances still :initializing, diff offerings, drive cadence probes.
+          module RefreshHelpers
+            private
+
+            def tick_refresh
+              reconcile_configured_instances
+              states = state_mutex.synchronize do
+                @instance_states.each_pair.map { |instance_id, state| [instance_id, state] }
+              end
+              states.each do |instance_id, state|
+                refresh_instance(instance_id: instance_id, state: state)
+              rescue StandardError => e
+                handle_exception(e, level: :warn, operation: 'azure_foundry.actor.refresh_instance',
+                                    instance_id: instance_id)
+              end
+              Legion::Extensions::Llm::Inventory::WeightReconciler.observe_dormant!(
+                settings: Legion::Settings,
+                provider_family: :azure_foundry,
+                states: @instance_states,
+                mutex: state_mutex,
+                tracker: dormant_weight_tracker,
+                dormant_logger: lambda do |key|
+                  log.info(
+                    "[llm][azure_foundry] action=dormant_weight weight_key=#{key.inspect} no_lane_published=true"
+                  )
+                end
+              )
+            end
+
+            # Re-scans configured instances every tick so instances configured
+            # after boot appear without a restart, and removed instances are
+            # released from the registry.
+            def reconcile_configured_instances
+              discovered = configured_instances
+              claim_new_instances(discovered)
+              release_removed_instances(discovered)
+            end
+
+            def refresh_instance(instance_id:, state:)
+              status = publisher.snapshot.publication_status(instance_key: state[:instance_key])
+              return log.debug { "[azure_foundry] no publication status for #{instance_id}; skipping refresh" } if
+                status.nil?
+
+              if status.state == :initializing
+                refresh_cached_offerings(instance_id: instance_id, state: state) unless state[:last_probe_outcome].nil?
+                run_initialization_probe(instance_id: instance_id, state: state)
+              else
+                refresh_activated_instance(instance_id: instance_id, state: state)
+              end
+            end
 
             def refresh_activated_instance(instance_id:, state:)
               new_offerings = discover_offerings_for_instance(
                 instance_cfg: state[:instance_cfg], instance_key: state[:instance_key]
               )
-
-              if offerings_changed?(previous: state[:offerings], current: new_offerings)
-                replace_instance_offerings(instance_id: instance_id, state: state, offerings: new_offerings)
-                state[:offerings] = new_offerings
+              changed = commit_weight_snapshot(
+                instance_id: instance_id, state: state, offerings: new_offerings
+              )
+              if changed
                 write_instance_health(
                   config_name: state[:name], available: true, reason: 'offerings refreshed',
                   probe_outcome: state[:last_probe_outcome], source: :discovery,
-                  capabilities: instance_capabilities(new_offerings)
+                  capabilities: instance_capabilities(state[:offerings])
                 )
               end
 
               run_cadence_probe(instance_id: instance_id, state: state)
             end
-
-            def replace_instance_offerings(instance_id:, state:, offerings:)
-              state[:sequence] += 1
-              publisher.replace_instance_snapshot(
-                instance_id: instance_id, publisher_token: state[:publisher_token],
-                offerings: offerings, sequence: state[:sequence],
-                physical_id: state[:instance_key].physical_id
-              )
-            end
           end
 
           # Display-only health + capabilities projection into
@@ -846,6 +932,8 @@ module Legion
             include ProbeHelpers
             include ShutdownHelpers
             include ActivationHelpers
+            include WeightPublicationHelpers
+            include InitialReadinessHelpers
             include RefreshHelpers
             include DiscoveryHealthDisplay
 
@@ -862,6 +950,8 @@ module Legion
 
             def manual
               @instance_states ||= Concurrent::Map.new
+              state_mutex
+              dormant_weight_tracker
               tick_refresh
             rescue StandardError => e
               handle_exception(e, level: :warn, operation: 'azure_foundry.actor.discovery_refresh')
@@ -875,6 +965,14 @@ module Legion
 
             private
 
+            def state_mutex
+              @state_mutex ||= Mutex.new
+            end
+
+            def dormant_weight_tracker
+              @dormant_weight_tracker ||= Legion::Extensions::Llm::Inventory::DormantWeightTracker.new
+            end
+
             # D9: the tick interval is the registered discovery.interval_seconds.
             # A missing or non-positive value falls back to the registered
             # default — never nil (a nil interval stops the TimerTask after the

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module AzureFoundry
-        VERSION = '0.3.4'
+        VERSION = '0.3.5'
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-azure-foundry
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.3.5
 platform: ruby
 authors:
 - LegionIO
@@ -71,14 +71,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.7.1
+        version: 0.7.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.7.1
+        version: 0.7.6
 description: Azure AI Foundry and Azure OpenAI hosted provider integration for LegionIO
   LLM routing.
 email: