lex-llm-anthropic 0.3.4 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a55d5c398f1718d6cb12d15d3c2aa5c5b5e40216ac1de25119ad5ab36bfc04e
-  data.tar.gz: 29f41f8a7d528f3b25055368daa731ed87fb16c64680ae3c6bd7267e33227313
+  metadata.gz: 37a7bf28c47d62711e925d75c0717bf45c952d4b899a5c84794f7544a395ad21
+  data.tar.gz: caad53642cf6b4123b41a30a0941dae91c587b7c79e89f16c49d737fb76aae13
 SHA512:
-  metadata.gz: 06a7a0c4e20303cc0fd969c18409e11a3daf88cc3c9b02907b3d3b5fff77cf53b3f04f24b4541d9c49eb879f336d0fdda10767840748c3dfddc405474eb1dc61
-  data.tar.gz: ca5ba8689d3ee56ec091a6adcedfd98c9ce37697e8bab4c3e21a0dacd7784ca03071fee2387da41c9fb833e54a7217b60a4d3c9198484f192fa2121c146e6c3a
+  metadata.gz: 217cbbf2136c44b3a362c78a8d787c646ac6a93746a3bd967a279301023cc5050e39fef902c38e624c1f7080806785784c1df93432c469c96221dbfb059c66b9
+  data.tar.gz: d6677021c2251c507705c6ada10d5378f54d97e20ea7176b0b00099ca62269063d593fce722c3d051dae53294eca1a8797769b7bf4edb18fb519fea485ef8b5b

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.3.5] - 2026-08-19
+
+### Changed
+- **Write-time SSOT lane weights** — Anthropic discovery now computes the validated four-axis weight pair for every offering and reconciles weight-only changes on the existing periodic discovery cadence. Initial and recovery activation rebuild from current settings, and publication, sequence, and cache mutation share the actor's existing serialization boundary.
+- **Dependency floor** — Requires `lex-llm >= 0.7.6` for the shared weight schema, immutable record pair, dormant-weight tracker, and atomic reconciler. The existing `legion-settings` floor and lifecycle remain unchanged.
+
+### Fixed
+- **Complete discovery change detection** — Ordinary discovery cadence now compares the full stable `OfferingDraft` contract, excluding only telemetry-only evidence timestamps. Provider-native identity, evidence authority and metadata, scalar limits, quota domains, offering metadata, publication source, and weights all trigger one atomic replacement when changed; catalog reordering remains stable without collapsing duplicate offerings.
+- **Two-phase publication races** — Offering and weight validation now completes before allocating a callable, probe coordinator, publisher token, registry scope, or local state; malformed weight configuration cannot strand an untracked claim or activate a healthy zero-lane instance. Claimed instances are tracked as unpublished before readiness I/O; removal wins a late-readiness race, and publisher failures leave cached state retryable without sequence drift.
+- **Callable-path system conformance** — The provider formatter now accepts folded canonical messages as well as the legacy message shape. An end-to-end canonical fixture proves a folded leading system message reaches Anthropic's rendered native `system` field.
+
 ## [0.3.4] - 2026-08-18
 
 ### Fixed

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

@@ -13,6 +13,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'
@@ -51,6 +52,10 @@ module Legion
             # Per-instance capabilities advertised in the settings health display,
             # mirroring the legacy discover_instances output.
             INSTANCE_CAPABILITIES = %i[completion streaming vision tools].freeze
+            SCALAR_EVIDENCE_FIELDS = %i[
+              context_evidence max_output_evidence embedding_dimensions_evidence
+              model_revision_evidence tokenizer_evidence
+            ].freeze
 
             def runner_class    = self.class
             def runner_function = 'manual'
@@ -115,10 +120,17 @@ module Legion
               end
             end
 
+            def dormant_weight_tracker
+              @dormant_weight_tracker ||= Legion::Extensions::Llm::Inventory::DormantWeightTracker.new
+            end
+
             # ── Initial discovery ─────────────────────────────────────────────
 
             def initial_discovery
-              with_instance_states { @instance_states = {} }
+              with_instance_states do |states|
+                states.clear
+                dormant_weight_tracker.clear!
+              end
               configured_instances.each do |name, instance_cfg|
                 claim_and_activate_instance(name:, instance_cfg:)
               rescue StandardError => e
@@ -136,6 +148,10 @@ module Legion
                 provider_family: :anthropic, instance_id: instance_id, physical_id: physical_id
               )
 
+              # Validate the complete offering set before allocating any
+              # callable, probe coordinator, publisher token, or local state.
+              offerings = discover_offerings_for_instance(instance_cfg:, instance_key:)
+
               callable = AnthropicCallable.new(instance_cfg: instance_cfg, logger: log)
               probe_coordinator = Legion::Extensions::Llm::Inventory::ProbeCoordinator.new(
                 instance_key: instance_key,
@@ -149,7 +165,23 @@ module Legion
                 physical_id:          physical_id
               )
 
-              offerings = discover_offerings_for_instance(instance_cfg:, instance_key:)
+              state = {
+                name:              name,
+                instance_key:      instance_key,
+                physical_id:       physical_id,
+                instance_cfg:      instance_cfg,
+                callable:          callable,
+                probe_coordinator: probe_coordinator,
+                publisher_token:   publisher_token,
+                sequence:          0,
+                offerings:         offerings,
+                signature:         offering_signature(offerings),
+                published:         false
+              }
+              states = with_instance_states { |instance_states| instance_states }
+              Legion::Extensions::Llm::Inventory::WeightReconciler.track_initializing!(
+                states: states, state_key: instance_id, state: state, mutex: state_mutex
+              )
 
               probe_token = publisher.readiness_probe_started(
                 instance_id:     instance_id,
@@ -160,15 +192,14 @@ module Legion
               readiness = check_readiness(instance_cfg:)
 
               if readiness.ready?
-                publisher.activate_instance_snapshot(
-                  instance_id:     instance_id,
-                  publisher_token: publisher_token,
-                  offerings:       offerings,
-                  sequence:        0,
-                  probe_token:     probe_token,
-                  physical_id:     physical_id
+                activated = Legion::Extensions::Llm::Inventory::WeightReconciler.activate_tracked!(
+                  settings: Legion::Settings, instance_id: instance_id, state_key: instance_id,
+                  state: state, states: states, mutex: state_mutex, probe_token: probe_token,
+                  activate: method(:activate_weight_snapshot),
+                  activation_sequence: ->(tracked) { tracked.fetch(:sequence) },
+                  stable_signature: method(:offering_signature)
                 )
-                write_instance_display(name: name, ready: true, reason: readiness.reason)
+                write_instance_display(name: name, ready: true, reason: readiness.reason) if activated
               else
                 publisher.readiness_failed(
                   instance_id: instance_id,
@@ -178,21 +209,6 @@ module Legion
                 )
                 write_instance_display(name: name, ready: false, reason: readiness.reason)
               end
-
-              with_instance_states do
-                @instance_states[instance_id] = {
-                  name:              name,
-                  instance_key:      instance_key,
-                  physical_id:       physical_id,
-                  instance_cfg:      instance_cfg,
-                  callable:          callable,
-                  probe_coordinator: probe_coordinator,
-                  publisher_token:   publisher_token,
-                  sequence:          0,
-                  offerings:         offerings,
-                  signature:         offering_signature(offerings)
-                }
-              end
             end
 
             # ── Tick refresh ──────────────────────────────────────────────────
@@ -200,6 +216,7 @@ module Legion
             def tick_refresh
               reconcile_instances
               refresh_tracked_instances
+              observe_dormant_weights
             end
 
             # Re-scan configured instances each tick so instances added or removed
@@ -258,6 +275,7 @@ module Legion
                 instance_cfg: state[:instance_cfg],
                 instance_key: state[:instance_key]
               )
+              cache_discovered_offerings(instance_id:, state:, offerings:)
               probe_token = publisher.readiness_probe_started(
                 instance_id:     instance_id,
                 publisher_token: state[:publisher_token],
@@ -266,19 +284,15 @@ module Legion
               readiness = check_readiness(instance_cfg: state[:instance_cfg])
 
               if readiness.ready?
-                publisher.activate_instance_snapshot(
-                  instance_id:     instance_id,
-                  publisher_token: state[:publisher_token],
-                  offerings:       offerings,
-                  sequence:        0,
-                  probe_token:     probe_token,
-                  physical_id:     state[:physical_id]
+                states = with_instance_states { |instance_states| instance_states }
+                activated = Legion::Extensions::Llm::Inventory::WeightReconciler.activate_tracked!(
+                  settings: Legion::Settings, instance_id: instance_id, state_key: instance_id,
+                  state: state, states: states, mutex: state_mutex, probe_token: probe_token,
+                  activate: method(:activate_weight_snapshot),
+                  activation_sequence: ->(tracked) { tracked.fetch(:sequence) },
+                  stable_signature: method(:offering_signature)
                 )
-                with_instance_states do
-                  state[:offerings] = offerings
-                  state[:signature] = offering_signature(offerings)
-                end
-                write_instance_display(name: state[:name], ready: true, reason: readiness.reason)
+                write_instance_display(name: state[:name], ready: true, reason: readiness.reason) if activated
               else
                 publisher.readiness_failed(
                   instance_id: instance_id,
@@ -298,29 +312,85 @@ module Legion
                 instance_cfg: state[:instance_cfg],
                 instance_key: state[:instance_key]
               )
-              new_signature = offering_signature(new_offerings)
-              return if new_signature == state[:signature]
-
-              sequence = with_instance_states do
-                state[:sequence] += 1
-                state[:sequence]
+              changed = Legion::Extensions::Llm::Inventory::WeightReconciler.commit_if_changed!(
+                settings: Legion::Settings, instance_id: instance_id, state: state,
+                discovered_offerings: new_offerings, mutex: state_mutex,
+                equivalent: lambda { |previous, current|
+                  offering_signature(previous) == offering_signature(current)
+                },
+                replace: method(:replace_weight_snapshot),
+                stable_signature: method(:offering_signature)
+              )
+              published = with_instance_states do |states|
+                states[instance_id].equal?(state) && state[:published]
               end
+              write_instance_display(name: state[:name], ready: true, reason: 'offerings refreshed') \
+                if changed && published
+              changed
+            end
+
+            def cache_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: state_mutex,
+                equivalent: lambda { |previous, current|
+                  offering_signature(previous) == offering_signature(current)
+                },
+                replace: method(:replace_weight_snapshot),
+                stable_signature: method(:offering_signature)
+              )
+            end
+
+            def replace_weight_snapshot(instance_id:, state:, offerings:, sequence:)
               publisher.replace_instance_snapshot(
-                instance_id:     instance_id,
-                publisher_token: state[:publisher_token],
-                offerings:       new_offerings,
-                sequence:        sequence,
-                physical_id:     state[:physical_id]
+                instance_id: instance_id, publisher_token: state.fetch(:publisher_token),
+                offerings: offerings, sequence: sequence, physical_id: state.fetch(: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(:physical_id)
               )
-              with_instance_states do
-                state[:offerings] = new_offerings
-                state[:signature] = new_signature
-              end
-              write_instance_display(name: state[:name], ready: true, reason: 'offerings refreshed')
             end
 
             def offering_signature(offerings)
-              offerings.map { |offering| [offering.model, offering.tier] }.sort.freeze
+              # A tally is an order-independent multiset: catalog reordering is
+              # stable while duplicate offerings remain visible to comparison.
+              offerings.map { |offering| stable_offering_state(offering) }.tally.freeze
+            end
+
+            def stable_offering_state(offering)
+              state = offering.to_h
+              state[:operation_evidence] = stable_evidence_map(offering.operation_evidence)
+              state[:capability_evidence] = stable_evidence_map(offering.capability_evidence)
+              SCALAR_EVIDENCE_FIELDS.each do |field|
+                state[field] = stable_evidence(offering.public_send(field))
+              end
+              state.freeze
+            end
+
+            def stable_evidence_map(evidence)
+              evidence.transform_values { |entry| stable_evidence(entry) }.freeze
+            end
+
+            def stable_evidence(evidence)
+              evidence.to_h.except(:observed_at).freeze
+            end
+
+            def observe_dormant_weights
+              states = with_instance_states { |instance_states| instance_states }
+              Legion::Extensions::Llm::Inventory::WeightReconciler.observe_dormant!(
+                settings: Legion::Settings, provider_family: :anthropic, states: states,
+                mutex: state_mutex, tracker: dormant_weight_tracker,
+                dormant_logger: lambda { |key|
+                  log.info(
+                    "[llm][anthropic] action=dormant_weight weight_key=#{key.inspect} no_lane_published=true"
+                  )
+                }
+              )
             end
 
             # ── Readiness probing ─────────────────────────────────────────────
@@ -449,7 +519,7 @@ module Legion
                   instance_key: instance_key
                 )
               end
-            rescue StandardError => e
+            rescue Faraday::Error, Legion::JSON::ParseError => e
               handle_exception(e, level: :warn, operation: 'anthropic.actor.discover_offerings')
               []
             end
@@ -466,6 +536,10 @@ module Legion
 
             def build_offering_draft(model_id:, model_data:, instance_cfg:, instance_key:)
               tier = instance_cfg[:tier] || :frontier
+              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,
@@ -480,7 +554,9 @@ module Legion
                 tokenizer_evidence:            absent_value_evidence,
                 quota_domains:                 {},
                 metadata:                      { raw_model: model_id, instance_id: instance_key.instance_id }.freeze,
-                publication_source:            :provider_catalog
+                publication_source:            :provider_catalog,
+                weight_inputs:                 weight_inputs,
+                base_weight:                   Legion::Extensions::Llm::Inventory::WeightSchema.base_weight(weight_inputs)
               )
             end
 
@@ -638,21 +714,33 @@ module Legion
             def remove_all_instances
               tracked = with_instance_states { @instance_states.dup }
               tracked.each_value { |state| retire_instance(state) }
-              with_instance_states { @instance_states.clear }
+              with_instance_states do |states|
+                states.clear
+                dormant_weight_tracker.clear!
+              end
             end
 
             # Retire one instance: remove it from the registry, drop the local
             # state, clear its settings display, and close its callable.
             def retire_instance(state)
               instance_id = state[:instance_key].instance_id
-              publisher.remove_instance(
-                instance_id:     instance_id,
-                publisher_token: state[:publisher_token],
-                physical_id:     state[:physical_id]
-              )
-              with_instance_states { @instance_states.delete(instance_id) }
+              removed = state_mutex.synchronize do
+                @instance_states ||= {}
+                next false unless @instance_states[instance_id].equal?(state)
+
+                publisher.remove_instance(
+                  instance_id:     instance_id,
+                  publisher_token: state[:publisher_token],
+                  physical_id:     state[:physical_id]
+                )
+                @instance_states.delete(instance_id)
+                true
+              end
+              return false unless removed
+
               clear_instance_display(name: state[:name])
               state[:callable]&.disconnect
+              true
             rescue StandardError => e
               handle_exception(e, level: :warn, operation: 'anthropic.actor.retire_instance',
                                   instance_id: instance_id)

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

@@ -144,9 +144,9 @@ module Legion
           def format_messages(messages, thinking:, cacheable_count: 0)
             messages.each_with_index.map do |message, index|
               cache = index < cacheable_count
-              if message.tool_call?
+              if message_tool_call?(message)
                 format_tool_call_message(message, thinking:, cache:)
-              elsif message.tool_result?
+              elsif message_tool_result?(message)
                 format_tool_result_message(message, cache:)
               else
                 {
@@ -207,10 +207,18 @@ module Legion
           def with_thinking(blocks, message, enabled)
             return blocks unless enabled && message&.role == :assistant
 
-            thinking_block = thinking_block(message.thinking)
+            thinking_block = thinking_block(message.respond_to?(:thinking) ? message.thinking : nil)
             thinking_block ? [thinking_block, *blocks] : blocks
           end
 
+          def message_tool_call?(message)
+            !message.tool_calls.nil? && !message.tool_calls.empty?
+          end
+
+          def message_tool_result?(message)
+            !message.tool_call_id.nil? && !message.tool_call_id.to_s.empty?
+          end
+
           def format_tool_call_message(message, thinking:, cache:)
             blocks = content_blocks(message.content, thinking:, message:, cache:)
             # tool_calls is an Array of ToolCall since the adapter stopped

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

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

metadata

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