lex-llm-bedrock 0.5.4 → 0.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0457af083b20a03a506e162791bb8e460483dd05da16c6f208e4411af673315d
-  data.tar.gz: 13c7ac1b8ecc5737f141dc5c3327baf9068eb955a6d5d57fefc8688939322521
+  metadata.gz: 5dff754b7817098396287ff77ec64205f5dea845b43eddd9c73ddb742b8b638c
+  data.tar.gz: 754c16f98e51acfcfaee31bf936741616adb92bacb7042956f278d7ff65f9c66
 SHA512:
-  metadata.gz: 2334dbb6abcd57924ba64329fc1691fada8190d84acc3e7cb98d6fdc60b4b202e53a57258c356e2385e32da3379f81083dfd1f3ffb307291a2cd208b31e0da11
-  data.tar.gz: d3d290e0b54de08ae5d2fbf517fe0b5a448faa8d568f849c3dbde381f21b2461fc9aa9c688482181bf1be4ff1e105579392b75eebd43b02ffb86258fa840bbf9
+  metadata.gz: 3a674c63e6fd3f99855f89dcbd63319148751ff4dea85596a1cf6024a90d5de015ba35eb8c7bff563143f40608ced83dbda1196794569560c7df79337c545e17
+  data.tar.gz: 645ed19662a6b3097202b494a4ef941f08b7fdc39d8af8feed201fa13b341697736f0b517294b0980d0bad7009dc81f60e6f3ad95abf2987cc4ed36971c1c064

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.5.5] - 2026-08-19
+
+### Added
+- **Callable-path system conformance** — The production `BedrockCallable#chat` path now has a rendered-wire fixture proving a folded leading system message reaches the AWS Converse payload's native `system` field.
+
+### Changed
+- **Write-time SSOT lane weights** — Bedrock discovery computes the shared four-component weight pair for every offering, reconciles weight-only changes on the existing `Actors::Every` cadence, and publishes immutable weighted snapshots without adding a Settings callback, reload path, restart, migration, or operator step.
+- **Atomic writer lifecycle** — Initial and recovery activation, ordinary replacement, state removal, sequence allocation, cached offerings, and dormant-weight tracking now share one actor mutex. Initializing states never replace, failed publisher calls leave the cache retryable, and late readiness cannot resurrect a removed state.
+- **Dependency floor** — Requires `lex-llm >= 0.7.6` for `WeightSchema`, weighted Inventory records, `WeightReconciler`, and `DormantWeightTracker`; the existing `legion-settings >= 1.4.2` floor is unchanged.
+
+### Fixed
+- **Startup validation cannot orphan an initializing claim** — Initial offering construction and write-time weight validation now finish before Bedrock creates a callable or probe coordinator and before Inventory issues a publisher token. A malformed weight leaves no Registry status, callable, token, or actor state; the next corrected cadence claims and activates normally.
+- **Ordinary discovery compares the complete offering contract** — Replacement detection now retains every authoritative `OfferingDraft` field and ignores only evidence observation timestamps. Catalog order is set-like while duplicate multiplicity remains visible, so metadata, quota, evidence-source/value, publication-source, native-key, capability, operation, tier, or weight drift publishes exactly once without churn from reorder-only discovery.
+
 ## [0.5.4] - 2026-08-18
 
 ### Fixed

data/lex-llm-bedrock.gemspec

@@ -29,5 +29,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/bedrock/actors/discovery_refresh.rb

@@ -18,6 +18,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/taxonomies'
 require 'legion/extensions/llm/capabilities'
 
@@ -225,6 +226,13 @@ module Legion
                 input_mods: input_mods, output_mods: output_mods,
                 streaming_supported: streaming, 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,
                 operation_evidence: op_ev,
@@ -236,7 +244,9 @@ module Legion
                 tokenizer_evidence: build_tokenizer_evidence,
                 quota_domains: build_quota_domains(instance_cfg: instance_cfg, model_id: model_id),
                 metadata: build_offering_metadata(model_id: model_id, instance_key: instance_key),
-                publication_source: :provider_catalog
+                publication_source: :provider_catalog,
+                weight_inputs: weight_inputs,
+                base_weight: Legion::Extensions::Llm::Inventory::WeightSchema.base_weight(weight_inputs)
               )
             end
 
@@ -380,7 +390,7 @@ module Legion
             end
 
             def handle_reactive_probe(instance_id:, request:)
-              state = @instance_states[instance_id]
+              state = instance_state_mutex.synchronize { @instance_states[instance_id] }
               return unless state
 
               coordinator = state[:probe_coordinator]
@@ -435,6 +445,11 @@ module Legion
           # tick reconciliation, shutdown, and the post-commit settings health
           # + capabilities display writes (D14).
           module DiscoveryOrchestrationHelpers
+            SCALAR_EVIDENCE_FIELDS = %i[
+              context_evidence max_output_evidence embedding_dimensions_evidence
+              model_revision_evidence tokenizer_evidence
+            ].freeze
+
             private
 
             # SSOT instance source, shared with the fleet worker/runner: every
@@ -507,6 +522,7 @@ module Legion
               instance_key = Legion::Extensions::Llm::Inventory::Identity::InstanceKey.new(
                 provider_family: :bedrock, instance_id: instance_id, physical_id: physical_id
               )
+              offerings = discover_offerings_for_instance(instance_cfg: instance_cfg, instance_key: instance_key)
               callable = BedrockCallable.new(instance_cfg: instance_cfg, logger: log)
               probe_coordinator = Legion::Extensions::Llm::Inventory::ProbeCoordinator.new(
                 instance_key: instance_key,
@@ -516,31 +532,33 @@ module Legion
                 instance_id: instance_id, callable: callable, probe_request_handle: probe_coordinator,
                 physical_id: physical_id
               )
-              offerings = discover_offerings_for_instance(instance_cfg: instance_cfg, instance_key: instance_key)
-              probe_token = publisher.readiness_probe_started(instance_id: instance_id, physical_id: physical_id,
-                                                              publisher_token: publisher_token)
-              readiness = check_health(instance_cfg: instance_cfg)
-
               state = {
                 name: name, instance_key: instance_key, instance_cfg: instance_cfg,
                 callable: callable, probe_coordinator: probe_coordinator,
                 publisher_token: publisher_token, sequence: 0, offerings: offerings,
-                last_probe_outcome: nil
+                published: false, last_probe_outcome: nil
               }
-              @instance_states[instance_id] = state
+              Legion::Extensions::Llm::Inventory::WeightReconciler.track_initializing!(
+                states: @instance_states, state_key: instance_id, state: state,
+                mutex: instance_state_mutex
+              )
+
+              probe_token = publisher.readiness_probe_started(instance_id: instance_id, physical_id: physical_id,
+                                                              publisher_token: publisher_token)
+              readiness = check_health(instance_cfg: instance_cfg)
 
               if readiness.ready?
-                publisher.activate_instance_snapshot(
-                  instance_id: instance_id, physical_id: physical_id, publisher_token: publisher_token,
-                  offerings: offerings, sequence: state[:sequence], probe_token: probe_token
+                activated = activate_tracked_snapshot(
+                  instance_id: instance_id, state: state, probe_token: probe_token
                 )
-                state[:last_probe_outcome] = :success
+                state[:last_probe_outcome] = :success if activated
               else
                 publisher.readiness_failed(instance_id: instance_id, physical_id: physical_id,
                                            probe_token: probe_token, reason: readiness.reason)
                 state[:last_probe_outcome] = :failure
               end
-              write_instance_health(name: name, state: state, reason: readiness.reason)
+              write_instance_health(name: name, state: state, reason: readiness.reason) \
+                if tracked_instance_state?(instance_id: instance_id, state: state)
             end
 
             def tick_refresh
@@ -549,25 +567,50 @@ module Legion
 
               claimable.each do |name, instance_cfg|
                 instance_id = name.to_s
-                state = @instance_states[instance_id]
+                state = instance_state_mutex.synchronize { @instance_states[instance_id] }
                 if state.nil?
                   claim_and_activate_instance(name: name, instance_cfg: instance_cfg)
-                elsif state[:instance_cfg] != instance_cfg
+                elsif runtime_instance_config(state[:instance_cfg]) != runtime_instance_config(instance_cfg)
                   # Config changed under a live instance: re-claim with the new
                   # identity/config rather than mutating a live publication.
                   remove_instance_state(instance_id: instance_id)
                   claim_and_activate_instance(name: name, instance_cfg: instance_cfg)
                 else
+                  instance_state_mutex.synchronize do
+                    state[:instance_cfg] = instance_cfg if @instance_states[instance_id].equal?(state)
+                  end
                   refresh_instance(instance_id: instance_id, state: state)
                 end
               rescue StandardError => e
                 handle_exception(e, level: :warn, operation: 'bedrock.actor.tick_refresh', instance_name: name.to_s)
               end
+              observe_dormant_weights
+            end
+
+            # Weight is publication data, not callable/credential identity. Ignore only
+            # the instance and instance-model weight fields when deciding whether an
+            # existing callable must be torn down and re-claimed; every other config
+            # change preserves the existing re-claim behavior.
+            def runtime_instance_config(instance_cfg)
+              runtime = instance_cfg.dup
+              runtime.delete(:weight)
+              runtime.delete('weight')
+              models_key = runtime.key?(:models) ? :models : 'models'
+              models = runtime[models_key]
+              return runtime unless models.is_a?(::Hash)
+
+              runtime[models_key] = models.to_h do |model, model_config|
+                next [model, model_config] unless model_config.is_a?(::Hash)
+
+                [model, model_config.except(:weight, 'weight')]
+              end
+              runtime
             end
 
             def reconcile_removed_instances(claimable)
               claimed_ids = claimable.keys.map(&:to_s)
-              @instance_states.each_key do |instance_id|
+              tracked_ids = instance_state_mutex.synchronize { @instance_states.keys }
+              tracked_ids.each do |instance_id|
                 next if claimed_ids.include?(instance_id)
 
                 remove_instance_state(instance_id: instance_id)
@@ -587,7 +630,7 @@ module Legion
             end
 
             def publication_initializing?(state)
-              publisher.snapshot.publication_status(instance_key: state[:instance_key]).state == :initializing
+              instance_state_mutex.synchronize { !state.fetch(:published) }
             end
 
             def reactivate_if_ready(instance_id:, state:)
@@ -600,13 +643,11 @@ module Legion
                 offerings = discover_offerings_for_instance(
                   instance_cfg: state[:instance_cfg], instance_key: state[:instance_key]
                 )
-                state[:offerings] = offerings
-                publisher.activate_instance_snapshot(
-                  instance_id: instance_id, physical_id: state[:instance_key].physical_id,
-                  publisher_token: state[:publisher_token],
-                  offerings: offerings, sequence: state[:sequence], probe_token: probe_token
+                reconcile_offerings(instance_id: instance_id, state: state, offerings: offerings)
+                activated = activate_tracked_snapshot(
+                  instance_id: instance_id, state: state, probe_token: probe_token
                 )
-                state[:last_probe_outcome] = :success
+                state[:last_probe_outcome] = :success if activated
               else
                 publisher.readiness_failed(
                   instance_id: instance_id, physical_id: state[:instance_key].physical_id,
@@ -614,60 +655,150 @@ module Legion
                 )
                 state[:last_probe_outcome] = :failure
               end
-              write_instance_health(name: state[:name], state: state, reason: readiness.reason)
+              write_instance_health(name: state[:name], state: state, reason: readiness.reason) \
+                if tracked_instance_state?(instance_id: instance_id, state: 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]
               )
-              # Compare on identity/status, not Data#==: evidence carries a
-              # fresh observed_at per discovery and would force a replace
-              # (generation bump) every tick on an unchanged catalog.
-              return if offerings_signature(new_offerings) == offerings_signature(state[:offerings])
+              changed = reconcile_offerings(instance_id: instance_id, state: state, offerings: new_offerings)
+              write_instance_health(name: state[:name], state: state, reason: 'offerings refreshed') \
+                if changed && state[:published]
+            end
+
+            def reconcile_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_signature(previous) == offerings_signature(current)
+                end,
+                replace: method(:replace_weight_snapshot)
+              )
+            end
 
-              state[:sequence] += 1
+            def replace_weight_snapshot(instance_id:, state:, offerings:, sequence:)
               publisher.replace_instance_snapshot(
-                instance_id: instance_id, physical_id: state[:instance_key].physical_id,
-                publisher_token: state[:publisher_token],
-                offerings: new_offerings, sequence: state[:sequence]
+                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_tracked_snapshot(instance_id:, state:, probe_token:)
+              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) }
+              )
+            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
               )
-              state[:offerings] = new_offerings
-              write_instance_health(name: state[:name], state: state, reason: 'offerings refreshed')
             end
 
             def offerings_signature(offerings)
-              signatures = offerings.map do |draft|
-                {
-                  model: draft.model,
-                  tier: draft.tier,
-                  operations: draft.operation_evidence.transform_values(&:status).sort.to_h,
-                  capabilities: draft.capability_evidence.transform_values(&:status).sort.to_h
-                }
+              contracts = offerings.map { |draft| stable_offering_contract(draft) }
+              grouped = contracts.group_by do |contract|
+                [contract.fetch(:provider_native_key), contract.fetch(:model)]
               end
-              signatures.sort_by { |entry| entry[:model].to_s }
+              grouped.sort_by { |identity, _| identity.map { |value| value.to_s.b } }
+                     .to_h.transform_values(&:tally)
+            end
+
+            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 stable_evidence_map(evidence_by_key)
+              evidence_by_key.transform_values { |evidence| stable_evidence(evidence) }
+            end
+
+            def stable_evidence(evidence)
+              evidence.to_h.except(:observed_at)
             end
 
             def remove_instance_state(instance_id:)
-              state = @instance_states.delete(instance_id)
+              state = instance_state_mutex.synchronize { @instance_states.delete(instance_id) }
               return unless state
 
+              remove_published_state(state)
+            rescue StandardError => e
+              handle_exception(e, level: :warn, operation: 'bedrock.actor.remove_instance', instance_id: instance_id)
+            end
+
+            def remove_all_instances
+              return unless @instance_states
+
+              states = instance_state_mutex.synchronize do
+                removed = @instance_states.values
+                @instance_states.clear
+                dormant_weight_tracker.clear!
+                removed
+              end
+              states.each { |state| remove_published_state(state) }
+            end
+
+            def remove_published_state(state)
               publisher.remove_instance(
                 instance_id: state[:instance_key].instance_id,
                 physical_id: state[:instance_key].physical_id,
                 publisher_token: state[:publisher_token]
               )
               clear_instance_health(name: state[:name])
-            rescue StandardError => e
-              handle_exception(e, level: :warn, operation: 'bedrock.actor.remove_instance', instance_id: instance_id)
             end
 
-            def remove_all_instances
-              return unless @instance_states
+            def tracked_instance_state?(instance_id:, state:)
+              instance_state_mutex.synchronize { @instance_states[instance_id].equal?(state) }
+            end
 
-              @instance_states.each_key do |instance_id|
-                remove_instance_state(instance_id: instance_id)
-              end
+            def observe_dormant_weights
+              Legion::Extensions::Llm::Inventory::WeightReconciler.observe_dormant!(
+                settings: ::Legion::Settings,
+                provider_family: :bedrock,
+                states: @instance_states,
+                mutex: instance_state_mutex,
+                tracker: dormant_weight_tracker,
+                dormant_logger: lambda do |key|
+                  log.info(
+                    "[llm][bedrock] action=dormant_weight weight_key=#{key.inspect} no_lane_published=true"
+                  )
+                end
+              )
+            end
+
+            def instance_state_mutex
+              @instance_state_mutex ||= Mutex.new
+            end
+
+            def dormant_weight_tracker
+              @dormant_weight_tracker ||= Legion::Extensions::Llm::Inventory::DormantWeightTracker.new
             end
 
             # ── D14: settings health + capabilities display writes ────────────
@@ -807,12 +938,14 @@ module Legion
             end
 
             def initial_discovery
-              @instance_states = {}
+              instance_state_mutex.synchronize { @instance_states = {} }
+              dormant_weight_tracker
               claimable_instances.each do |name, instance_cfg|
                 claim_and_activate_instance(name: name, instance_cfg: instance_cfg)
               rescue StandardError => e
                 handle_exception(e, level: :warn, operation: 'bedrock.actor.claim_instance', instance_name: name.to_s)
               end
+              observe_dormant_weights
             end
           end
         end

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module Bedrock
-        VERSION = '0.5.4'
+        VERSION = '0.5.5'
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-bedrock
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.5.5
 platform: ruby
 authors:
 - LegionIO
@@ -99,14 +99,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: Amazon Bedrock provider integration for the LegionIO LLM routing framework.
 email:
 - matthewdiverson@gmail.com