lex-llm-ollama 0.3.4 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a7cb2a1511c933e0174c414ba400ef0d7fcc700feeb2ac866be66004447f9df9
-  data.tar.gz: 90756cc1de56697e25880b801a07016a6e0d6b5edda22025b053850716e267cf
+  metadata.gz: c00ff8929f8723127315d78b2141144a64319b2af41526098397717f4833568a
+  data.tar.gz: 2bc5494b6cdd8ec0f4268218e530719baeadd75126c71f70bdbbc96f4e4fc468
 SHA512:
-  metadata.gz: 603aee402d7b5f0733369fb78c45430ac452ae33d2f8cf05adc7871552ba19f556cd43ab9cf3986ad8a9644798fd0924b394c5d39aff4150ffcc5714003ec299
-  data.tar.gz: 27a834f6be3252033fcc7f8028d8fd44f2056202bb7adf441f01b34f35832791aa6ac69c55db782398a509255af45f6c0ede82733d21dc7b19aa166683590b53
+  metadata.gz: b3a2b92564e059f37584612350f1e67a1f260d224b3237feaa8ba3158d4cef7d741765930dbd6a3d34694fcb7d8b1ce50ec43da743874a558134fbe32a9ad454
+  data.tar.gz: 6f79d61f8fd32e268d1363c21a78209f41a78560d8f22f8a60cfe0d5c35f97a3987e0900fb111b99b5721fe23d94bc9842f4132f86a3fe64c2f828c10c38984f

data/CHANGELOG.md

@@ -3,6 +3,10 @@
 ## [Unreleased]
 
 ### Fixed
+- **Complete discovery change detection** — ordinary discovery now compares the complete stable `OfferingDraft#to_h` contract as an order-independent, duplicate-count-preserving multiset. Only evidence `observed_at` telemetry is excluded; quota domains, metadata, publication source, scalar evidence authority, and every other draft field trigger one atomic replacement when changed.
+- **Startup claim atomicity** — initial model discovery and write-time weight validation now complete before Ollama constructs a callable, coordinator, or Registry claim, so malformed settings cannot leave an orphan `:initializing` publication status or token; the next corrected discovery pass claims and activates the instance exactly once without a restart or operator repair.
+- **SSOT v3 write-time weights** — Ollama drafts now publish the validated four-axis weight pair from live settings, and the existing discovery cadence atomically reconciles weight-only changes, initialization/activation races, sequence/cache updates, removals, and dormant configured-weight logging through lex-llm 0.7.6. No Settings callback, reload, reset, migration, restart, or operator action is introduced.
+- **D14 callable-path wire conformance** — the actual `OllamaCallable#chat` path now accepts Task-01 canonical folded messages and renders the authoritative system content as the leading Ollama `role: system` message; legacy message tool-result handling remains intact.
 - Remove synthetic-default discovery filtering and its once-per-boot warning; configured discovery now passes every instance entry through normal enabled and endpoint validation.
 - **D1 Callable dispatch** — `OllamaCallable` now implements the fleet dispatch ops (`chat`, `stream_chat`, `embed`, `count_tokens`) by delegating to a per-instance `Ollama::Provider` (previously hardcoded fake payloads that swallowed `messages:` into `**`); errors propagate unrescued for `normalize_dispatch_error`; `disconnect` closes the Provider. Optional `provider:` injection seam for specs (production builds the real Provider lazily).
 - **D15 Raw-string model at the dispatch boundary** — the fleet passes `model:` as the offering's raw id (String). Ollama's render path is string-tolerant (`model.respond_to?(:id) ? model.id : model`) for chat and embed, embed places the model verbatim in the `Embedding` response object, and count_tokens ignores it — so the raw string passes through UNWRAPPED on every op (wrapping would serialize a `Data` object into the wire payload or the response object); `Model::Info` instances pass through unchanged.

data/lex-llm-ollama.gemspec

@@ -27,7 +27,6 @@ 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'
-  # 0.7.1 carries the name-identity InstanceKey (instance_id = config name +
-  # secondary physical_id field) that the SSOT v3 discovery actor publishes.
-  spec.add_dependency 'lex-llm', '>= 0.7.1'
+  # 0.7.6 adds write-time WeightSchema records and the atomic writer reconciler.
+  spec.add_dependency 'lex-llm', '>= 0.7.6'
 end

data/lib/legion/extensions/llm/ollama/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'
@@ -248,6 +249,13 @@ module Legion
               tier = instance_cfg[:tier] || :local
               detail = fetch_model_detail_safe(model_name: model_name, instance_cfg: instance_cfg)
               embed_supported = embedding_model?(model_name: model_name, model_data: model_data)
+              weight_inputs = Legion::Extensions::Llm::Inventory::WeightSchema.weight_inputs(
+                settings: Legion::Settings,
+                instance_key: instance_key,
+                provider_native_key: model_name,
+                model: model_name,
+                tier: tier
+              )
 
               Legion::Extensions::Llm::Inventory::OfferingDraft.new(
                 provider_native_key: model_name,
@@ -267,7 +275,9 @@ module Legion
                 quota_domains: {},
                 metadata: build_offering_metadata(model_name: model_name, model_data: model_data)
                           .merge(instance_id: instance_key.instance_id),
-                publication_source: :provider_catalog
+                publication_source: :provider_catalog,
+                weight_inputs: weight_inputs,
+                base_weight: Legion::Extensions::Llm::Inventory::WeightSchema.base_weight(weight_inputs)
               )
             end
 
@@ -401,7 +411,7 @@ module Legion
             # name is the CONFIG NAME — the @instance_states key. The
             # publisher calls use the state's instance_id + physical_id pair.
             def handle_reactive_probe(name:, request:)
-              state = @instance_states[name]
+              state = @state_mutex.synchronize { @instance_states[name] }
               return unless state
 
               coordinator = state[:probe_coordinator]
@@ -503,52 +513,40 @@ module Legion
 
           # ── 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 draft embeds fresh evidence observed_at telemetry. Compare
+            # the complete stable draft contract as a multiset so catalog order
+            # is irrelevant while duplicate counts remain significant.
             def offerings_changed?(previous:, current:)
-              current.map { |draft| offering_signature(draft) } !=
-                previous.map { |draft| offering_signature(draft) }
+              offering_multiset(current) != offering_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_multiset(offerings)
+              offerings.map { |draft| stable_offering_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 stable_offering_state(draft)
+              state = draft.to_h
+              state[:operation_evidence] = stable_evidence_map(draft.operation_evidence)
+              state[:capability_evidence] = stable_evidence_map(draft.capability_evidence)
+              SCALAR_EVIDENCE_FIELDS.each do |field|
+                state[field] = stable_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 stable_evidence_map(evidence)
+              evidence.transform_values { |entry| stable_evidence(entry) }
             end
 
-            def value_pair(evidence)
-              [evidence.status, evidence.value]
+            def stable_evidence(evidence)
+              evidence.to_h.except(:observed_at)
             end
           end
 
@@ -668,11 +666,11 @@ 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(
                 name: name.to_sym, instance_id: instance_id, physical_id: physical_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.to_sym,
                 instance_id: instance_id,
@@ -685,25 +683,113 @@ module Legion
                 sequence: 0,
                 offerings: offerings
               }
-              settle_initial_readiness(state: state)
-              @instance_states[name.to_sym] = state
-              sync_display_health(state: state)
+              Legion::Extensions::Llm::Inventory::WeightReconciler.track_initializing!(
+                states: @instance_states,
+                state_key: name.to_sym,
+                state: state,
+                mutex: @state_mutex
+              )
+              settled = settle_initial_readiness(state: state)
+              sync_display_health(state: state) if settled
             end
 
             def drop_instance(name:, state:)
-              publisher.remove_instance(
-                instance_id: state[:instance_id], physical_id: state[:physical_id],
-                publisher_token: state[:publisher_token]
-              )
+              removed = @state_mutex.synchronize do
+                next false unless @instance_states[name].equal?(state)
+
+                publisher.remove_instance(
+                  instance_id: state[:instance_id], physical_id: state[:physical_id],
+                  publisher_token: state[:publisher_token]
+                )
+                @instance_states.delete(name)
+                true
+              end
+              return unless removed
+
               state[:callable]&.disconnect
               clear_display_health(name: state[:name])
-              @instance_states.delete(name)
             rescue StandardError => e
               handle_exception(e, level: :warn, operation: 'ollama.actor.remove_instance',
                                   instance_id: state[:instance_id])
             end
           end
 
+          # Atomic adapters and dormant observation shared by the existing
+          # discovery cadence. Sequence and cache mutation remain owned by
+          # lex-llm's WeightReconciler.
+          module WeightPublication
+            private
+
+            def replace_offerings_if_changed(state:)
+              new_offerings = discover_offerings_for_instance(
+                instance_cfg: state[:instance_cfg], instance_key: state[:instance_key]
+              )
+              changed = Legion::Extensions::Llm::Inventory::WeightReconciler.commit_if_changed!(
+                settings: Legion::Settings,
+                instance_id: state[:instance_id],
+                state: state,
+                discovered_offerings: new_offerings,
+                mutex: @state_mutex,
+                equivalent: lambda do |previous, current|
+                  !offerings_changed?(previous: previous, current: current)
+                end,
+                replace: method(:replace_weight_snapshot)
+              )
+              published = @state_mutex.synchronize { state[:published] }
+              sync_display_health(state: state) if changed && published
+              changed
+            end
+
+            def replace_weight_snapshot(instance_id:, state:, offerings:, sequence:)
+              publisher.replace_instance_snapshot(
+                instance_id: instance_id,
+                physical_id: state[: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 observe_dormant_weights
+              Legion::Extensions::Llm::Inventory::WeightReconciler.observe_dormant!(
+                settings: Legion::Settings,
+                provider_family: :ollama,
+                states: @instance_states,
+                mutex: @state_mutex,
+                tracker: @dormant_weight_tracker,
+                dormant_logger: lambda do |key|
+                  log.info do
+                    "[llm][ollama] action=dormant_weight weight_key=#{key.inspect} no_lane_published=true"
+                  end
+                end
+              )
+            end
+
+            def remove_all_instances
+              return unless @instance_states
+
+              states = @state_mutex.synchronize { @instance_states.each_pair.to_a }
+              states.each do |name, state|
+                drop_instance(name: name, state: state)
+              end
+              @state_mutex.synchronize do
+                @instance_states.clear
+                @dormant_weight_tracker.clear!
+              end
+            end
+          end
+
           # Per-instance SSOT lifecycle: reconcile configured instances each
           # tick, run the readiness state machine (initial probe, recovery
           # while :initializing, cadence probes, snapshot replacement), and
@@ -713,6 +799,8 @@ module Legion
 
             def initial_discovery
               @instance_states = Concurrent::Map.new
+              @state_mutex = Mutex.new
+              @dormant_weight_tracker = Legion::Extensions::Llm::Inventory::DormantWeightTracker.new
               reconcile_and_refresh
             end
 
@@ -728,10 +816,11 @@ module Legion
             # distinct, independently-managed instances.
             def reconcile_and_refresh
               configured = configured_instances
-              existing = @instance_states.keys
+              existing = @state_mutex.synchronize { @instance_states.keys }
               add_newly_configured_instances(configured: configured)
               remove_unconfigured_instances(configured: configured)
-              @instance_states.each do |name, state|
+              states = @state_mutex.synchronize { @instance_states.each_pair.to_a }
+              states.each do |name, state|
                 next unless existing.include?(name)
 
                 refresh_instance(state: state)
@@ -739,11 +828,13 @@ module Legion
                 handle_exception(e, level: :warn, operation: 'ollama.actor.refresh_instance',
                                     instance_id: state[:instance_id])
               end
+              observe_dormant_weights
             end
 
             def add_newly_configured_instances(configured:)
               configured.each do |name, instance_cfg|
-                next if @instance_states.key?(name.to_sym)
+                tracked = @state_mutex.synchronize { @instance_states.key?(name.to_sym) }
+                next if tracked
 
                 claim_and_activate_instance(name: name, instance_cfg: instance_cfg)
               rescue StandardError => e
@@ -752,7 +843,8 @@ module Legion
             end
 
             def remove_unconfigured_instances(configured:)
-              @instance_states.each do |name, state|
+              states = @state_mutex.synchronize { @instance_states.each_pair.to_a }
+              states.each do |name, state|
                 next if configured.key?(name)
 
                 drop_instance(name: name, state: state)
@@ -772,68 +864,48 @@ module Legion
               )
               readiness = check_readiness(instance_cfg: state[:instance_cfg])
               if readiness.ready?
-                publisher.activate_instance_snapshot(
-                  instance_id: instance_id, physical_id: physical_id,
-                  publisher_token: state[:publisher_token],
-                  offerings: state[:offerings], sequence: 0, probe_token: probe_token
+                Legion::Extensions::Llm::Inventory::WeightReconciler.activate_tracked!(
+                  settings: Legion::Settings,
+                  instance_id: instance_id,
+                  state_key: state[:name],
+                  state: state,
+                  states: @instance_states,
+                  mutex: @state_mutex,
+                  probe_token: probe_token,
+                  activate: method(:activate_weight_snapshot),
+                  activation_sequence: ->(tracked) { tracked.fetch(:sequence) }
                 )
               else
+                tracked = @state_mutex.synchronize { @instance_states[state[:name]].equal?(state) }
+                return false unless tracked
+
                 publisher.readiness_failed(
                   instance_id: instance_id, physical_id: physical_id,
                   probe_token: probe_token, reason: readiness.reason
                 )
+                true
               end
             end
 
             def refresh_instance(state:)
-              if publication_state(instance_key: state[:instance_key]) == :initializing
-                retry_initial_activation(state: state)
-              else
+              published = @state_mutex.synchronize { state[:published] }
+              if published
                 replace_offerings_if_changed(state: state)
                 run_cadence_probe(state: state)
+              else
+                retry_initial_activation(state: state)
               end
             end
 
-            def publication_state(instance_key:)
-              publisher.snapshot.publication_status(instance_key: instance_key).state
-            end
-
             # An instance that failed initial readiness stays :initializing —
             # readiness_succeeded and replace_instance_snapshot both refuse to
             # operate on an :initializing scope, so without this re-activation
             # 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(state:)
-              state[:offerings] = discover_offerings_for_instance(
-                instance_cfg: state[:instance_cfg], instance_key: state[:instance_key]
-              )
-              settle_initial_readiness(state: state)
-              sync_display_health(state: state)
-            end
-
-            def replace_offerings_if_changed(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: state[:instance_id], physical_id: state[:physical_id],
-                publisher_token: state[:publisher_token],
-                offerings: new_offerings, sequence: state[:sequence]
-              )
-              state[:offerings] = new_offerings
-              sync_display_health(state: state)
-            end
-
-            def remove_all_instances
-              return unless @instance_states
-
-              @instance_states.each do |name, state|
-                drop_instance(name: name, state: state)
-              end
-              @instance_states.clear
+              replace_offerings_if_changed(state: state)
+              settled = settle_initial_readiness(state: state)
+              sync_display_health(state: state) if settled
             end
           end
 
@@ -857,6 +929,7 @@ module Legion
             include OfferingComparison
             include DisplayHealth
             include InstanceComponents
+            include WeightPublication
             include InstanceLifecycle
 
             def runner_class    = self.class

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

@@ -405,7 +405,12 @@ module Legion
               content = message.content
               payload = { role: message.role.to_s, content: format_content(content) }
               payload[:images] = encoded_attachments(content) if content.respond_to?(:attachments)
-              payload[:tool_call_id] = message.tool_call_id if message.tool_result?
+              tool_result = if message.respond_to?(:tool_result?)
+                              message.tool_result?
+                            else
+                              message.role.to_sym == :tool
+                            end
+              payload[:tool_call_id] = message.tool_call_id if tool_result && message.respond_to?(:tool_call_id)
               payload
             end
           end

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

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

metadata

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