lex-llm-gemini 0.4.4 → 0.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b3524657be64163617964f55cfeb0f375536587ebb79f1d118d8b7b53032b59d
-  data.tar.gz: f80938bffd0e0f8794a0de0cc7857064cf1db3c19c948042acdfb423da63d9ec
+  metadata.gz: 4fc6c5255eae71b411f35c57a052ac77bb3d9aecdb2855672472f8b1a4f4f514
+  data.tar.gz: af8645870657d5f743b398c88f96cb2a74cb849eb15afa3553b723c0d02c2f58
 SHA512:
-  metadata.gz: 42f5f91e84ca2b380f983dbe04d4f4ff1171cf06c4aa14cf4b884e219700869c19e85b57c39f90e57bbca81f9b9b490a9e11dab2bff5641d55b0e03bfc02ea3b
-  data.tar.gz: a70c14d20367d1e7b2dfe57647cfa1a56f235396087707a84759732e408b6b37aa366cde5e2ee5957fdcce7e252ac9f3ec45d8c255d95de821a53c8447a99ba2
+  metadata.gz: cbdc6a0ff9351f061590beedecfaeba3ccd78666aa97db675e9ff2a528834a22ba5542afd3b63bb143f8d34cd7756b0bc3719a48a84cc4423997d9dd0e07fb3e
+  data.tar.gz: 5cfcce92073c6e27a86e20b5200ae0b0babf5eec1061c20c43928c9dd34e63b0fce8311f57d7637ca4d70d49c6134d69b5b45950e415604ad3ee77e6597097c9

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [0.4.5] - 2026-08-19
+
+### Changed
+- Publish the validated four-axis lane weight pair on every Gemini offering and reconcile weight-only changes atomically on the existing discovery cadence.
+- Track initializing instances before readiness, rebuild weights from current settings at activation, and serialize activation, replacement, removal, and cache mutation behind one writer mutex.
+
+### Fixed
+- Report configured-but-unpublished Gemini weight keys once per dormant cycle without adding a settings callback or operator workflow.
+- Render canonical system messages through the actual Gemini callable path as native `systemInstruction` payloads.
+- Validate weighted offering drafts before constructing or claiming a callable scope, so malformed weights leave no orphaned Registry publication and a later corrected ordinary pass activates without restart or operator cleanup.
+- Compare rebuilt catalogs as duplicate-preserving multisets of complete offering contracts, ignoring only evidence observation timestamps so catalog reordering cannot churn snapshots and authoritative metadata, quota, publication-source, or evidence-source changes cannot be missed.
+
+### Dependencies
+- Raise the `lex-llm` floor from `>= 0.7.1` to `>= 0.7.6`; the `legion-settings` floor remains unchanged.
+
 ## [0.4.4] - 2026-08-18
 
 ### Fixed

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

@@ -23,6 +23,7 @@ require 'legion/extensions/llm/inventory/identity'
 require 'legion/extensions/llm/inventory/records'
 require 'legion/extensions/llm/inventory/evidence'
 require 'legion/extensions/llm/inventory/probe_coordinator'
+require 'legion/extensions/llm/inventory/weight_reconciler'
 require 'legion/extensions/llm/routing/provider_outcome'
 require 'legion/extensions/llm/taxonomies'
 require 'legion/extensions/llm/capabilities'
@@ -212,9 +213,18 @@ module Legion
             def build_offering_draft(model_id:, model_data:, instance_cfg:, instance_key:)
               tier = instance_cfg[:tier] || :frontier
               generation_methods = extract_generation_methods(model_data: model_data)
+              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(generation_methods: generation_methods),
                 capability_evidence: build_capability_evidence(generation_methods: generation_methods),
                 context_evidence: build_context_evidence(model_data: model_data),
@@ -432,7 +442,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]
@@ -537,52 +547,40 @@ module Legion
           # ── Instance lifecycle helpers ───────────────────────────────────────
           # ── Offering change comparison helpers ───────────────────────────────
           module OfferingComparison
+            SCALAR_EVIDENCE_FIELDS = %i[
+              context_evidence max_output_evidence embedding_dimensions_evidence
+              model_revision_evidence tokenizer_evidence
+            ].freeze
+
             private
 
-            # Compare on identity and evidence status, not Data#==: every draft
-            # embeds a fresh Time.now observed_at, so Data equality is false
-            # across ticks even when the model set and capabilities are
-            # unchanged (replace churn on every tick).
+            # Every catalog pass rebuilds evidence observation timestamps. The
+            # timestamps are telemetry, but every other draft field remains
+            # authoritative. Catalog order is not authoritative; multiplicity is.
             def offerings_changed?(previous:, current:)
-              current.map { |draft| offering_signature(draft) } !=
-                previous.map { |draft| offering_signature(draft) }
+              offering_comparison_multiset(current) != offering_comparison_multiset(previous)
             end
 
-            def offering_signature(draft)
-              [
-                draft.provider_native_key,
-                draft.model,
-                draft.tier,
-                operation_signature(draft),
-                capability_signature(draft),
-                value_signature(draft)
-              ]
+            def offering_comparison_multiset(offerings)
+              Array(offerings).map { |draft| offering_comparison_state(draft) }.tally
             end
 
-            def operation_signature(draft)
-              draft.operation_evidence.values.map do |evidence|
-                [evidence.operation, evidence.status, evidence.source]
-              end.sort
-            end
-
-            def capability_signature(draft)
-              draft.capability_evidence.values.map do |evidence|
-                [evidence.capability, evidence.status, evidence.source]
-              end.sort
+            def offering_comparison_state(draft)
+              state = draft.to_h
+              state[:operation_evidence] = comparison_evidence_map(draft.operation_evidence)
+              state[:capability_evidence] = comparison_evidence_map(draft.capability_evidence)
+              SCALAR_EVIDENCE_FIELDS.each do |field|
+                state[field] = comparison_evidence(draft.public_send(field))
+              end
+              state
             end
 
-            def value_signature(draft)
-              [
-                value_pair(draft.context_evidence),
-                value_pair(draft.max_output_evidence),
-                value_pair(draft.embedding_dimensions_evidence),
-                value_pair(draft.model_revision_evidence),
-                value_pair(draft.tokenizer_evidence)
-              ]
+            def comparison_evidence_map(evidence)
+              evidence.transform_values { |entry| comparison_evidence(entry) }
             end
 
-            def value_pair(evidence)
-              [evidence.status, evidence.value]
+            def comparison_evidence(evidence)
+              evidence.to_h.except(:observed_at)
             end
           end
 
@@ -696,9 +694,9 @@ module Legion
               instance_id  = name.to_s
               physical_id  = derive_physical_id(instance_cfg: 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)
               components   = build_instance_components(instance_id: instance_id, instance_cfg: instance_cfg,
                                                        instance_key: instance_key)
-              offerings    = discover_offerings_for_instance(instance_cfg: instance_cfg, instance_key: instance_key)
               state        = {
                 name: name,
                 instance_id: instance_id,
@@ -708,24 +706,101 @@ module Legion
                 probe_coordinator: components[:probe_coordinator],
                 publisher_token: components[:publisher_token],
                 sequence: 0,
-                offerings: offerings
+                offerings: offerings,
+                published: false
               }
+              Legion::Extensions::Llm::Inventory::WeightReconciler.track_initializing!(
+                states: @instance_states, state_key: instance_id, state: state, mutex: @instance_state_mutex
+              )
               settle_initial_readiness(instance_id: instance_id, state: state)
-              @instance_states[instance_id] = state
-              sync_display_health(state: state)
+              sync_display_health(state: state) if tracked_instance_state(instance_id).equal?(state)
             end
 
             def drop_instance(instance_id:, state:)
-              publisher.remove_instance(
-                instance_id: instance_id, publisher_token: state[:publisher_token],
-                physical_id: state[:instance_key].physical_id
-              )
+              removed = @instance_state_mutex.synchronize do
+                next false unless @instance_states[instance_id].equal?(state)
+
+                publisher.remove_instance(
+                  instance_id: instance_id, publisher_token: state[:publisher_token],
+                  physical_id: state[:instance_key].physical_id
+                )
+                @instance_states.delete(instance_id)
+                true
+              end
+              return false unless removed
+
               state[:callable]&.disconnect
               clear_display_health(name: state[:name])
-              @instance_states.delete(instance_id)
+              true
             rescue StandardError => e
               handle_exception(e, level: :warn, operation: 'gemini.actor.remove_instance',
                                   instance_id: instance_id)
+              false
+            end
+          end
+
+          # Shared weight-reconciliation bindings and synchronized state access.
+          module WeightPublication
+            private
+
+            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,
+                publisher_token: state.fetch(:publisher_token),
+                offerings: offerings,
+                sequence: sequence,
+                physical_id: state.fetch(:instance_key).physical_id
+              )
+            end
+
+            def activate_weight_snapshot(instance_id:, state:, offerings:, sequence:, probe_token:)
+              publisher.activate_instance_snapshot(
+                instance_id: instance_id,
+                publisher_token: state.fetch(:publisher_token),
+                offerings: offerings,
+                sequence: sequence,
+                probe_token: probe_token,
+                physical_id: state.fetch(:instance_key).physical_id
+              )
+            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 observe_dormant_weights
+              Legion::Extensions::Llm::Inventory::WeightReconciler.observe_dormant!(
+                settings: Legion::Settings,
+                provider_family: :gemini,
+                states: @instance_states,
+                mutex: @instance_state_mutex,
+                tracker: @dormant_weight_tracker,
+                dormant_logger: lambda do |key|
+                  log.info do
+                    "[llm][gemini] action=dormant_weight weight_key=#{key.inspect} no_lane_published=true"
+                  end
+                end
+              )
             end
           end
 
@@ -738,6 +813,8 @@ module Legion
 
             def initial_discovery
               @instance_states = Concurrent::Map.new
+              @instance_state_mutex = Mutex.new
+              @dormant_weight_tracker = Legion::Extensions::Llm::Inventory::DormantWeightTracker.new
               reconcile_and_refresh
             end
 
@@ -750,10 +827,10 @@ module Legion
             # probe just ran; refresh and cadence probes start next tick.
             def reconcile_and_refresh
               configured = configured_instances
-              existing = @instance_states.keys
+              existing = instance_states_snapshot.keys
               add_newly_configured_instances(configured: configured)
               remove_unconfigured_instances(configured: configured)
-              @instance_states.each do |instance_id, state|
+              instance_states_snapshot.each do |instance_id, state|
                 next unless existing.include?(instance_id)
 
                 refresh_instance(instance_id: instance_id, state: state)
@@ -761,6 +838,7 @@ module Legion
                 handle_exception(e, level: :warn, operation: 'gemini.actor.refresh_instance',
                                     instance_id: instance_id)
               end
+              observe_dormant_weights
             end
 
             def add_newly_configured_instances(configured:)
@@ -769,7 +847,7 @@ module Legion
                 # id: two config names pointing at the same endpoint are
                 # distinct instances (the physical id never participates in
                 # identity).
-                next if @instance_states.key?(name.to_s)
+                next if tracked_instance_state(name.to_s)
 
                 claim_and_activate_instance(name: name, instance_cfg: instance_cfg)
               rescue StandardError => e
@@ -778,7 +856,7 @@ module Legion
             end
 
             def remove_unconfigured_instances(configured:)
-              @instance_states.each_value do |state|
+              instance_states_snapshot.each_value do |state|
                 next if configured.key?(state[:name])
 
                 drop_instance(instance_id: state[:instance_id], state: state)
@@ -796,9 +874,16 @@ module Legion
               )
               readiness = check_health(instance_cfg: state[:instance_cfg])
               if readiness.ready?
-                publisher.activate_instance_snapshot(
-                  instance_id: instance_id, publisher_token: state[:publisher_token],
-                  offerings: state[:offerings], sequence: 0, probe_token: probe_token, physical_id: physical_id
+                Legion::Extensions::Llm::Inventory::WeightReconciler.activate_tracked!(
+                  settings: Legion::Settings,
+                  instance_id: instance_id,
+                  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) }
                 )
               else
                 publisher.readiness_failed(
@@ -827,36 +912,34 @@ module Legion
             # path a transient outage at boot pins the instance for the process
             # lifetime. Re-probe each tick and activate once readiness passes.
             def retry_initial_activation(instance_id:, state:)
-              state[:offerings] = discover_offerings_for_instance(
+              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)
               settle_initial_readiness(instance_id: instance_id, state: state)
-              sync_display_health(state: state)
+              sync_display_health(state: state) if tracked_instance_state(instance_id).equal?(state)
             end
 
             def replace_offerings_if_changed(instance_id:, state:)
               new_offerings = discover_offerings_for_instance(
                 instance_cfg: state[:instance_cfg], instance_key: state[:instance_key]
               )
-              return unless offerings_changed?(previous: state[:offerings], current: new_offerings)
-
-              state[:sequence] += 1
-              publisher.replace_instance_snapshot(
-                instance_id: instance_id, publisher_token: state[:publisher_token],
-                offerings: new_offerings, sequence: state[:sequence],
-                physical_id: state[:instance_key].physical_id
+              changed = commit_discovered_offerings(
+                instance_id: instance_id, state: state, offerings: new_offerings
               )
-              state[:offerings] = new_offerings
-              sync_display_health(state: state)
+              sync_display_health(state: state) if changed
             end
 
             def remove_all_instances
               return unless @instance_states
 
-              @instance_states.each_value do |state|
+              instance_states_snapshot.each_value do |state|
                 drop_instance(instance_id: state[:instance_id], state: state)
               end
-              @instance_states.clear
+              @instance_state_mutex.synchronize do
+                @instance_states.clear
+                @dormant_weight_tracker.clear!
+              end
             end
           end
 
@@ -880,6 +963,7 @@ module Legion
             include OfferingComparison
             include DisplayHealth
             include InstanceComponents
+            include WeightPublication
             include InstanceLifecycle
 
             def runner_class    = self.class

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

@@ -6,6 +6,25 @@ module Legion
   module Extensions
     module Llm
       module Gemini
+        # Message-kind compatibility across legacy and Canonical message types.
+        module MessageKinds
+          private
+
+          def tool_call_message?(message)
+            return message.tool_call? if message.respond_to?(:tool_call?)
+
+            calls = message.tool_calls
+            !calls.nil? && !calls.empty?
+          end
+
+          def tool_result_message?(message)
+            return message.tool_result? if message.respond_to?(:tool_result?)
+
+            tool_call_id = message.tool_call_id
+            !tool_call_id.nil? && !tool_call_id.to_s.empty?
+          end
+        end
+
         # Message formatting helpers mixed into Provider.
         module MessageFormatter
           private
@@ -57,14 +76,14 @@ module Legion
 
           def gemini_role(message)
             return 'model' if message.role == :assistant
-            return 'function' if message.tool_result?
+            return 'function' if tool_result_message?(message)
 
             message.role.to_s
           end
 
           def message_parts(message)
-            return tool_call_parts(message) if message.tool_call?
-            return tool_result_parts(message) if message.tool_result?
+            return tool_call_parts(message) if tool_call_message?(message)
+            return tool_result_parts(message) if tool_result_message?(message)
 
             content_parts(message.content)
           end
@@ -327,6 +346,7 @@ module Legion
         # Gemini provider implementation for the Legion::Extensions::Llm base provider contract.
         class Provider < Legion::Extensions::Llm::Provider
           include Legion::Logging::Helper
+          include MessageKinds
           include MessageFormatter
           include ResponseParser
           include OfferingBuilder

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module Gemini
-        VERSION = '0.4.4'
+        VERSION = '0.4.5'
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-gemini
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.4.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: Gemini provider integration for the LegionIO LLM routing framework.
 email:
 - matthewdiverson@gmail.com