lex-llm-openai 0.6.3 → 0.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84567e208562add7567e8de290c9d69ce3a7ae7e10cfab7e7e6ddf92173d2b7d
-  data.tar.gz: 912a0379793e6e7dc10353aaf198ddc2c08b50310eb1642b8e2f7e5f1f244010
+  metadata.gz: f0ea7679c67d23d7a6b30bf8ec6057136f72c791c2846ffa805fa7fdb1b7b735
+  data.tar.gz: 3eb7f7fce099a71a77b6f5fa1acdc55610c870a0834aedcfa89c954bc7c8d687
 SHA512:
-  metadata.gz: a92b8cc928c93cf271ab575f15a9c582ddb4a53ceab09f8d0817a9b4268abc4dddcb997a11e926490c739798a9f25b763ea7cdbe3e348b328570f6ee3714b1fb
-  data.tar.gz: f8686fa71f7b9a23b7ee2f0a26bd74b8ea44afbefc33f6c47f0ed3836c34fe3e75acce1cd49bc98407a9ecf41e4937642f84b3fe0ce50f5d24c66b1f0da29884
+  metadata.gz: 7ff08b8ae9072732c1858bd7f88845496624c43a864d0d90d8727ca568d9edf8b59b538afdb87fc1081ddeb4354fd5c919db8bf89f6199d79f78b6c101f57792
+  data.tar.gz: c9162a28401cf7ac3544d06603f71bca9bf31a9e1136146146c23bdee261f1b90c698a2f17299f6a16e986ba0b7a0498c231f79a0bc4eb25aa456fdd4d2ac1f8

data/CHANGELOG.md

@@ -1,9 +1,15 @@
 # Changelog
 
-## [Unreleased]
+## [0.6.4] - 2026-08-19
 
 ### Fixed
+- **Write-time lane weights** — every discovered offering now carries the validated four-axis `weight_inputs` and `base_weight` pair from live settings. The existing periodic actor cadence atomically compares, publishes, sequences, and caches catalog or weight-only changes; unchanged passes stay no-op, initializing instances cache without replacing, and removals cannot race into late activation.
+- **Dormant weight visibility** — ordinary discovery passes emit one info log when a configured provider, instance, model, or offering weight has no published lane; the state clears when the lane appears and logs once again if it later disappears.
+- **D14 callable wire conformance** — an actual `OpenaiCallable#chat` request with a folded leading system message is captured at the provider connection and verified as OpenAI's native leading `role: system` message.
+- **Malformed discovery failures fail loud** — programming/configuration errors from draft construction are no longer swallowed as an empty catalog; only Faraday transport failures and JSON parse failures take the existing empty-discovery recovery path.
+- **lex-llm floor bumped to >= 0.7.6** — requires the shared `WeightSchema`, atomic `WeightReconciler`, weighted offering records, and operation-to-lane taxonomy used by this writer. The `legion-settings >= 1.4.2` floor and lifecycle remain unchanged.
 - **Credential-less configured instances are discovered normally** — removed the synthetic-default suppression and its one-time warning cache. A configured instance, including one named `default`, now follows the ordinary discovery and readiness path without a skip warning.
+- **Complete offering equivalence** — ordinary discovery now compares the complete `OfferingDraft` contract as an order-insensitive, duplicate-sensitive multiset, ignoring only evidence `observed_at` timestamps. Provider-native identity, publication source, tokenizer evidence, and all future draft fields trigger exactly one replacement when they change, while catalog reordering remains a no-op.
 
 ## [0.6.2] - 2026-08-17
 

data/lex-llm-openai.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/openai/actors/discovery_refresh.rb

@@ -9,8 +9,10 @@ require 'legion/extensions/llm/openai/discovery_evidence_builders'
 require 'legion/extensions/llm/openai/discovery_drafts'
 require 'legion/extensions/llm/openai/discovery_identity'
 require 'legion/extensions/llm/openai/discovery_probing'
+require 'legion/extensions/llm/openai/discovery_probe_reporting'
 require 'legion/extensions/llm/openai/discovery_transport'
 require 'legion/extensions/llm/openai/discovery_health_display'
+require 'legion/extensions/llm/openai/discovery_weight_publication'
 require 'legion/extensions/llm/inventory/publisher'
 require 'legion/extensions/llm/inventory/identity'
 require 'legion/extensions/llm/inventory/records'
@@ -54,8 +56,10 @@ module Legion
             include Legion::Extensions::Llm::Openai::DiscoveryDrafts
             include Legion::Extensions::Llm::Openai::DiscoveryIdentity
             include Legion::Extensions::Llm::Openai::DiscoveryProbing
+            include Legion::Extensions::Llm::Openai::DiscoveryProbeReporting
             include Legion::Extensions::Llm::Openai::DiscoveryTransport
             include Legion::Extensions::Llm::Openai::DiscoveryHealthDisplay
+            include Legion::Extensions::Llm::Openai::DiscoveryWeightPublication
 
             def runner_class    = self.class
             def runner_function = 'manual'
@@ -69,7 +73,7 @@ module Legion
             end
 
             def manual
-              @instance_states ||= {}
+              initialize_weight_publication
               tick_refresh
             rescue StandardError => e
               handle_exception(e, level: :warn, operation: 'openai.actor.discovery_refresh')
@@ -78,7 +82,11 @@ module Legion
             def shutdown
               return unless @instance_states
 
-              @instance_states.each_key { |instance_id| remove_instance_state(instance_id) }
+              instance_states_snapshot.each_key { |instance_id| remove_instance_state(instance_id) }
+              @instance_state_mutex.synchronize do
+                @instance_states.clear
+                @dormant_weight_tracker.clear!
+              end
             end
 
             private
@@ -109,12 +117,13 @@ module Legion
 
             def tick_refresh
               reconcile_configured_instances
-              @instance_states.each do |instance_id, state|
+              instance_states_snapshot.each do |instance_id, state|
                 refresh_instance(instance_id: instance_id, state: state)
               rescue StandardError => e
                 handle_exception(e, level: :warn, operation: 'openai.actor.refresh_instance',
                                     instance_id: instance_id)
               end
+              observe_dormant_weights
             end
 
             # Re-scans configured instances every tick so instances configured
@@ -128,10 +137,15 @@ module Legion
 
             def claim_new_instances(discovered)
               discovered.each do |name, instance_cfg|
-                next if @instance_states.key?(name.to_s)
-
-                @instance_states[name.to_s] = build_instance_context(
-                  name: name, instance_cfg: instance_cfg
+                instance_id = name.to_s
+                next if tracked_instance_state(instance_id)
+
+                state = build_instance_context(name: name, instance_cfg: instance_cfg)
+                Legion::Extensions::Llm::Inventory::WeightReconciler.track_initializing!(
+                  states: @instance_states,
+                  state_key: instance_id,
+                  state: state,
+                  mutex: @instance_state_mutex
                 )
               rescue StandardError => e
                 handle_exception(e, level: :warn, operation: 'openai.actor.claim_instance',
@@ -141,7 +155,9 @@ 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) }
+              (instance_states_snapshot.keys - discovered_names).each do |instance_id|
+                remove_instance_state(instance_id)
+              end
             end
 
             def build_instance_context(name:, instance_cfg:)
@@ -149,6 +165,9 @@ module Legion
               instance_key = Legion::Extensions::Llm::Inventory::Identity::InstanceKey.new(
                 provider_family: :openai, instance_id: name.to_s, physical_id: physical_id
               )
+              offerings = discover_offerings_for_instance(
+                instance_cfg: instance_cfg, instance_key: instance_key
+              )
               callable = Legion::Extensions::Llm::Openai::OpenaiCallable.new(instance_cfg: instance_cfg, logger: log)
               probe_coordinator = Legion::Extensions::Llm::Inventory::ProbeCoordinator.new(
                 instance_key: instance_key,
@@ -165,7 +184,8 @@ module Legion
                 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,
+                published: false
               }
             end
 
@@ -187,6 +207,8 @@ module Legion
             # calling replace/readiness_succeeded, which would raise
             # InvalidTransitionError.
             def run_initialization_probe(instance_id:, state:)
+              refresh_unpublished_offerings(instance_id: instance_id, state: state) \
+                if state[:last_probe_outcome] == :failure
               coordinator = state[:probe_coordinator]
               return unless coordinator.begin_probe
 
@@ -224,16 +246,24 @@ module Legion
             end
 
             def activate_after_readiness(instance_id:, state:, probe_token:)
-              state[:sequence] += 1
-              state[:last_probe_outcome] = :success
-              publisher.activate_instance_snapshot(
+              activated = Legion::Extensions::Llm::Inventory::WeightReconciler.activate_tracked!(
+                settings: Legion::Settings,
                 instance_id: instance_id,
-                physical_id: state[:physical_id],
-                publisher_token: state[:publisher_token],
-                offerings: state[:offerings],
-                sequence: state[:sequence],
-                probe_token: probe_token
+                state_key: instance_id,
+                state: state,
+                states: @instance_states,
+                mutex: @instance_state_mutex,
+                probe_token: probe_token,
+                activate: method(:activate_weight_snapshot),
+                activation_sequence: ->(tracked) { tracked.fetch(:sequence) + 1 }
               )
+              return unless activated
+
+              updated = update_tracked_instance(instance_id, state) do
+                state[:last_probe_outcome] = :success
+              end
+              return unless updated
+
               write_instance_health(
                 config_name: state[:name], available: true, reason: 'startup readiness succeeded',
                 probe_outcome: :success, source: :startup_readiness,
@@ -242,11 +272,15 @@ module Legion
             end
 
             def report_initial_failure(instance_id:, state:, probe_token:, reason:)
-              state[:last_probe_outcome] = :failure
               publisher.readiness_failed(
                 instance_id: instance_id, physical_id: state[:physical_id],
                 probe_token: probe_token, reason: reason
               )
+              updated = update_tracked_instance(instance_id, state) do
+                state[:last_probe_outcome] = :failure
+              end
+              return unless updated
+
               write_instance_health(
                 config_name: state[:name], available: false, reason: reason,
                 probe_outcome: :failure, source: :startup_readiness
@@ -259,16 +293,10 @@ module Legion
                 instance_key: state[:instance_key]
               )
 
-              if offerings_changed?(previous: state[:offerings], current: new_offerings)
-                state[:sequence] += 1
-                publisher.replace_instance_snapshot(
-                  instance_id: instance_id,
-                  physical_id: state[:physical_id],
-                  publisher_token: state[:publisher_token],
-                  offerings: new_offerings,
-                  sequence: state[:sequence]
-                )
-                state[:offerings] = new_offerings
+              changed = commit_discovered_offerings(
+                instance_id: instance_id, state: state, offerings: new_offerings
+              )
+              if changed && tracked_instance?(instance_id, state)
                 write_instance_health(
                   config_name: state[:name], available: true, reason: 'offerings refreshed',
                   probe_outcome: state[:last_probe_outcome], source: :discovery
@@ -278,17 +306,29 @@ module Legion
               run_cadence_probe(instance_id: instance_id, state: state)
             end
 
+            def refresh_unpublished_offerings(instance_id:, state:)
+              offerings = discover_offerings_for_instance(
+                instance_cfg: state[:instance_cfg], instance_key: state[:instance_key]
+              )
+              commit_discovered_offerings(instance_id: instance_id, state: state, offerings: offerings)
+            end
+
             # -- Removal -----------------------------------------------------------
 
             def remove_instance_state(instance_id)
-              state = @instance_states.delete(instance_id)
+              state = @instance_state_mutex.synchronize do
+                tracked = @instance_states[instance_id]
+                next unless tracked
+
+                publisher.remove_instance(
+                  instance_id: instance_id,
+                  physical_id: tracked[:physical_id],
+                  publisher_token: tracked[:publisher_token]
+                )
+                @instance_states.delete(instance_id)
+              end
               return unless state
 
-              publisher.remove_instance(
-                instance_id: instance_id,
-                physical_id: state[:physical_id],
-                publisher_token: state[:publisher_token]
-              )
               clear_instance_health(config_name: state[:name])
             rescue StandardError => e
               handle_exception(e, level: :warn, operation: 'openai.actor.remove_instance',
@@ -311,7 +351,7 @@ module Legion
                   instance_key: instance_key
                 )
               end
-            rescue StandardError => e
+            rescue Faraday::Error, Legion::JSON::ParseError => e
               handle_exception(e, level: :warn, operation: 'openai.actor.discover_offerings')
               []
             end
@@ -325,11 +365,20 @@ module Legion
             def build_offering_draft(model_id:, model_data:, instance_cfg:, instance_key:)
               tier = instance_cfg[:tier] || :frontier
               operations = infer_operations(model_id: model_id)
+              weight_inputs = Legion::Extensions::Llm::Inventory::WeightSchema.weight_inputs(
+                settings: Legion::Settings,
+                instance_key: instance_key,
+                provider_native_key: model_id,
+                model: model_id,
+                tier: tier
+              )
 
               Legion::Extensions::Llm::Inventory::OfferingDraft.new(
                 provider_native_key: model_id,
                 model: model_id,
                 tier: tier,
+                weight_inputs: weight_inputs,
+                base_weight: Legion::Extensions::Llm::Inventory::WeightSchema.base_weight(weight_inputs),
                 operation_evidence: build_operation_evidence(operations: operations),
                 capability_evidence: build_capability_evidence(model_id: model_id),
                 context_evidence: build_context_evidence(model_id: model_id, model_data: model_data),

data/lib/legion/extensions/llm/openai/discovery_drafts.rb

@@ -8,6 +8,12 @@ module Legion
         # DiscoveryRefresh. Extracted to keep the main class and the evidence
         # module within Metrics limits.
         module DiscoveryDrafts
+          EVIDENCE_MAP_FIELDS = %i[operation_evidence capability_evidence].freeze
+          VALUE_EVIDENCE_FIELDS = %i[
+            context_evidence max_output_evidence embedding_dimensions_evidence
+            model_revision_evidence tokenizer_evidence
+          ].freeze
+
           private
 
           # -- Operation inference -----------------------------------------------
@@ -55,56 +61,31 @@ module Legion
           # -- Offerings change detection (D3) -----------------------------------
           # Time.now observed_at stamps in the evidence poison Data#==, so a
           # rebuilt-but-unchanged catalog would otherwise replace the snapshot
-          # every tick. Compare identity/status fields only.
+          # every tick. Every other OfferingDraft field is authoritative.
 
           def offerings_changed?(previous:, current:)
-            return true unless previous.size == current.size
-
-            # Changed when any draft has no stable counterpart in the
-            # previous catalog (size mismatch or an identity/status diff).
-            current.any? do |draft|
-              previous.none? { |candidate| drafts_stable?(candidate, draft) }
-            end
-          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
+            offering_multiset(previous) != offering_multiset(current)
           end
 
-          def basic_fields_stable?(candidate, draft)
-            candidate.model == draft.model &&
-              candidate.tier == draft.tier &&
-              evidence_keys_stable?(candidate.operation_evidence, draft.operation_evidence) &&
-              evidence_keys_stable?(candidate.capability_evidence, draft.capability_evidence)
+          def offering_multiset(offerings)
+            offerings.map { |draft| stable_draft_state(draft) }.tally
           end
 
-          def evidence_keys_stable?(previous_map, current_map)
-            previous_map.keys.sort == current_map.keys.sort
-          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_draft_state(draft)
+            state = draft.to_h
+            EVIDENCE_MAP_FIELDS.each do |field|
+              state[field] = state.fetch(field).transform_values do |evidence|
+                stable_evidence_state(evidence)
+              end
             end
+            VALUE_EVIDENCE_FIELDS.each do |field|
+              state[field] = stable_evidence_state(state.fetch(field))
+            end
+            state
           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)
-          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_state(evidence)
+            evidence.to_h.except(:observed_at)
           end
         end
       end

data/lib/legion/extensions/llm/openai/discovery_probe_reporting.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Llm
+      module Openai
+        # Applies cadence/reactive readiness results after provider I/O.
+        module DiscoveryProbeReporting
+          private
+
+          def report_probe_result(instance_id:, probe_token:, readiness:, state:)
+            if readiness.ready?
+              report_probe_success(instance_id: instance_id, probe_token: probe_token, state: state)
+            else
+              report_probe_failure(
+                instance_id: instance_id, probe_token: probe_token, readiness: readiness, state: state
+              )
+            end
+          end
+
+          def report_probe_success(instance_id:, probe_token:, state:)
+            publisher.readiness_succeeded(
+              instance_id: instance_id, physical_id: state[:physical_id], probe_token: probe_token
+            )
+            updated = update_tracked_instance(instance_id, state) do
+              state[:last_probe_outcome] = :success
+            end
+            return unless updated
+
+            write_instance_health(
+              config_name: state[:name], available: true, reason: 'readiness probe succeeded',
+              probe_outcome: :success, source: :readiness_probe
+            )
+          end
+
+          def report_probe_failure(instance_id:, probe_token:, readiness:, state:)
+            publisher.readiness_failed(
+              instance_id: instance_id, physical_id: state[:physical_id],
+              probe_token: probe_token, reason: readiness.reason
+            )
+            updated = update_tracked_instance(instance_id, state) do
+              state[:last_probe_outcome] = :failure
+            end
+            return unless updated
+
+            write_instance_health(
+              config_name: state[:name], available: false, reason: readiness.reason,
+              probe_outcome: :failure, source: :readiness_probe
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/llm/openai/discovery_probing.rb

@@ -68,7 +68,7 @@ module Legion
           end
 
           def handle_reactive_probe(instance_id:, request:)
-            state = @instance_states[instance_id]
+            state = tracked_instance_state(instance_id)
             return unless state
 
             coordinator = state[:probe_coordinator]
@@ -95,29 +95,6 @@ module Legion
                                 instance_id: instance_id)
           end
 
-          def report_probe_result(instance_id:, probe_token:, readiness:, state:)
-            if readiness.ready?
-              publisher.readiness_succeeded(
-                instance_id: instance_id, physical_id: state[:physical_id], probe_token: probe_token
-              )
-              state[:last_probe_outcome] = :success
-              write_instance_health(
-                config_name: state[:name], available: true, reason: 'readiness probe succeeded',
-                probe_outcome: :success, source: :readiness_probe
-              )
-            else
-              publisher.readiness_failed(
-                instance_id: instance_id, physical_id: state[:physical_id],
-                probe_token: probe_token, reason: readiness.reason
-              )
-              state[:last_probe_outcome] = :failure
-              write_instance_health(
-                config_name: state[:name], available: false, reason: readiness.reason,
-                probe_outcome: :failure, source: :readiness_probe
-              )
-            end
-          end
-
           def build_probe_enqueue(instance_id:)
             proc do |request:|
               handle_reactive_probe(instance_id: instance_id, request: request)

data/lib/legion/extensions/llm/openai/discovery_weight_publication.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/llm/inventory/weight_reconciler'
+
+module Legion
+  module Extensions
+    module Llm
+      module Openai
+        # Binds the shared write-time weight reconciler to OpenAI's existing
+        # periodic discovery actor. Settings are read only during ordinary
+        # actor passes; this module never registers reload/reset callbacks.
+        module DiscoveryWeightPublication
+          private
+
+          def initialize_weight_publication
+            @instance_states ||= {}
+            @instance_state_mutex ||= Mutex.new
+            dormant_weight_tracker
+          end
+
+          def dormant_weight_tracker
+            @dormant_weight_tracker ||= Legion::Extensions::Llm::Inventory::DormantWeightTracker.new
+          end
+
+          def commit_discovered_offerings(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: @instance_state_mutex,
+              equivalent: lambda do |previous, current|
+                !offerings_changed?(previous: previous, current: current)
+              end,
+              replace: method(:replace_weight_snapshot)
+            )
+          end
+
+          def replace_weight_snapshot(instance_id:, state:, offerings:, sequence:)
+            publisher.replace_instance_snapshot(
+              instance_id: instance_id,
+              physical_id: state.fetch(:physical_id),
+              publisher_token: state.fetch(:publisher_token),
+              offerings: offerings,
+              sequence: sequence
+            )
+          end
+
+          def activate_weight_snapshot(instance_id:, state:, offerings:, sequence:, probe_token:)
+            publisher.activate_instance_snapshot(
+              instance_id: instance_id,
+              physical_id: state.fetch(:physical_id),
+              publisher_token: state.fetch(:publisher_token),
+              offerings: offerings,
+              sequence: sequence,
+              probe_token: probe_token
+            )
+          end
+
+          def tracked_instance_state(instance_id)
+            return unless @instance_states && @instance_state_mutex
+
+            @instance_state_mutex.synchronize { @instance_states[instance_id] }
+          end
+
+          def instance_states_snapshot
+            @instance_state_mutex.synchronize { @instance_states.each_pair.to_h }
+          end
+
+          def update_tracked_instance(instance_id, state)
+            @instance_state_mutex.synchronize do
+              return false unless @instance_states[instance_id].equal?(state)
+
+              yield
+              true
+            end
+          end
+
+          def tracked_instance?(instance_id, state)
+            tracked_instance_state(instance_id).equal?(state)
+          end
+
+          def observe_dormant_weights
+            Legion::Extensions::Llm::Inventory::WeightReconciler.observe_dormant!(
+              settings: Legion::Settings,
+              provider_family: :openai,
+              states: @instance_states,
+              mutex: @instance_state_mutex,
+              tracker: dormant_weight_tracker,
+              dormant_logger: lambda do |key|
+                log.info do
+                  "[llm][openai] action=dormant_weight weight_key=#{key.inspect} no_lane_published=true"
+                end
+              end
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module Openai
-        VERSION = '0.6.3'
+        VERSION = '0.6.4'
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-openai
 version: !ruby/object:Gem::Version
-  version: 0.6.3
+  version: 0.6.4
 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: OpenAI provider integration for the LegionIO LLM routing framework.
 email:
 - matthewdiverson@gmail.com
@@ -103,8 +103,10 @@ files:
 - lib/legion/extensions/llm/openai/discovery_evidence_builders.rb
 - lib/legion/extensions/llm/openai/discovery_health_display.rb
 - lib/legion/extensions/llm/openai/discovery_identity.rb
+- lib/legion/extensions/llm/openai/discovery_probe_reporting.rb
 - lib/legion/extensions/llm/openai/discovery_probing.rb
 - lib/legion/extensions/llm/openai/discovery_transport.rb
+- lib/legion/extensions/llm/openai/discovery_weight_publication.rb
 - lib/legion/extensions/llm/openai/instance_discovery.rb
 - lib/legion/extensions/llm/openai/openai_callable.rb
 - lib/legion/extensions/llm/openai/provider.rb