lex-agentic-inference 0.1.9 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aab6451e969d15dec0c0611253cda68bf6395f73c94a107fb40bd6ac7906bfab
-  data.tar.gz: 35f5f2e847b918d8f39418ea2db34143cb7541051b39a904194c15cb5b7ea8ef
+  metadata.gz: d8d433f84cb7914fe6bbed1b49f6c4e2376d0fc2616981415d8bdabcec2549a0
+  data.tar.gz: 7bfd8bbd8210dfbd3a249735d3f4985fa5af6a33b93f9ee5d45e204fd36ab9ee
 SHA512:
-  metadata.gz: db120c178d16008756bb83b5c84548b27de13d60e628dcf0fbb96b3f4166ddab1e56a751241ae84876d68a6222eec2f4e863b9b51e27d09319aa1b645de4ed29
-  data.tar.gz: 41221a494ac82877d7795c4e4a609d6f52efaecb68248ade74359da358b43ac5b881cfbf6ec0d4c82e4c66ece948faf3fd36e0f0c3ff3c01505b9f7093e8a3c2
+  metadata.gz: 441a6d38e9fa3bc1911ae8c80a312336ae1462a810b262d309fb4fa07a5c5e0c55c76e1de748300928ba1c62e90dbb0fbc048037b83e0c03e1a387500d246180
+  data.tar.gz: 573dd89cbee59b4ea980ce2acea0afd0cc1d306e244be959f38081e88cd51bf0514e478a4ab5820f1b5b2bc155d965a147857a9d9c014f0c2292492d3fd68cf7

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.1.10] - 2026-07-16
+### Added
+- Per-identity prediction store and rolling accuracy: `PredictionStore` is now keyed by `identity:`, isolating each partner's predictions and outcomes
+- `PredictionStore#erase_partner!(identity:)` — removes all predictions and outcomes for the given identity, raising `ArgumentError` on mismatch
+- `Runners::Prediction#erase_partner!(identity:)` — delegates to the per-identity store, enabling selective data erasure
+- All runner methods (`predict`, `resolve_prediction`, `pending_predictions`, `prediction_accuracy`, `expire_stale_predictions`, `get_prediction`) accept `identity:` kwarg to route to the correct store
+
 ## [0.1.9] - 2026-05-07
 ### Fixed
 - Abductive reasoning decay now handles restored hypotheses with no `last_evaluated_at` timestamp instead of crashing the update cycle.

data/lib/legion/extensions/agentic/inference/prediction/client.rb

@@ -13,12 +13,14 @@ module Legion
             include Runners::Prediction
 
             def initialize(**)
-              @prediction_store = Helpers::PredictionStore.new
+              @prediction_stores = {}
             end
 
             private
 
-            attr_reader :prediction_store
+            def prediction_store(identity: nil)
+              @prediction_stores[identity] ||= Helpers::PredictionStore.new(identity: identity)
+            end
           end
         end
       end

data/lib/legion/extensions/agentic/inference/prediction/helpers/prediction_store.rb

@@ -9,9 +9,10 @@ module Legion
         module Prediction
           module Helpers
             class PredictionStore
-              attr_reader :predictions, :outcomes
+              attr_reader :predictions, :outcomes, :identity
 
-              def initialize
+              def initialize(identity: nil)
+                @identity = identity
                 @predictions = {}
                 @outcomes = []
               end
@@ -78,6 +79,16 @@ module Legion
                   }
                 end
               end
+
+              def erase_partner!(identity:)
+                raise ArgumentError, "identity mismatch: expected #{@identity.inspect}, got #{identity.inspect}" if @identity != identity
+
+                predictions_erased = @predictions.size
+                outcomes_erased = @outcomes.size
+                @predictions.clear
+                @outcomes.clear
+                { erased: true, identity: identity, predictions_erased: predictions_erased, outcomes_erased: outcomes_erased }
+              end
             end
           end
         end

data/lib/legion/extensions/agentic/inference/prediction/runners/prediction.rb

@@ -12,9 +12,10 @@ module Legion
               include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
                                                           Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
-              def predict(mode:, context: {}, confidence: nil, description: nil, **)
+              def predict(mode:, context: {}, confidence: nil, description: nil, identity: nil, **)
                 return { error: :invalid_mode, valid_modes: Helpers::Modes::REASONING_MODES } unless Helpers::Modes.valid_mode?(mode)
 
+                store = prediction_store(identity: identity)
                 prediction = {
                   prediction_id: SecureRandom.uuid,
                   mode:          mode,
@@ -26,10 +27,10 @@ module Legion
                   horizon:       Helpers::Modes::PREDICTION_HORIZON
                 }
 
-                prediction_store.store(prediction)
+                store.store(prediction)
 
                 actionable = prediction[:confidence] >= Helpers::Modes::PREDICTION_CONFIDENCE_MIN
-                rolling_accuracy = prediction_store.accuracy
+                rolling_accuracy = store.accuracy
                 log.debug "[prediction] new: mode=#{mode} confidence=#{prediction[:confidence].round(2)} " \
                           "actionable=#{actionable} accuracy=#{rolling_accuracy.round(2)} id=#{prediction[:prediction_id][0..7]}"
 
@@ -40,12 +41,13 @@ module Legion
                   actionable:       actionable,
                   rolling_accuracy: rolling_accuracy,
                   error_rate:       (1.0 - rolling_accuracy).round(4),
-                  resolved:         prediction_store.recently_resolved
+                  resolved:         store.recently_resolved
                 }
               end
 
-              def resolve_prediction(prediction_id:, outcome:, actual: nil, **)
-                pred = prediction_store.resolve(prediction_id, outcome: outcome, actual: actual)
+              def resolve_prediction(prediction_id:, outcome:, actual: nil, identity: nil, **)
+                store = prediction_store(identity: identity)
+                pred = store.resolve(prediction_id, outcome: outcome, actual: actual)
                 if pred
                   log.info "[prediction] resolved #{prediction_id[0..7]} outcome=#{outcome}"
                   record_outcome_trace(pred, outcome)
@@ -56,47 +58,54 @@ module Legion
                 end
               end
 
-              def pending_predictions(**)
-                preds = prediction_store.pending
+              def pending_predictions(identity: nil, **)
+                store = prediction_store(identity: identity)
+                preds = store.pending
                 log.debug "[prediction] pending count=#{preds.size}"
                 { predictions: preds, count: preds.size }
               end
 
-              def prediction_accuracy(window: 100, **)
-                acc = prediction_store.accuracy(window: window)
-                total = prediction_store.outcomes.size
+              def prediction_accuracy(window: 100, identity: nil, **)
+                store = prediction_store(identity: identity)
+                acc = store.accuracy(window: window)
+                total = store.outcomes.size
                 log.debug "[prediction] accuracy=#{acc.round(2)} total_outcomes=#{total}"
                 { accuracy: acc, total_outcomes: total }
               end
 
-              def expire_stale_predictions(**)
+              def expire_stale_predictions(identity: nil, **)
+                store = prediction_store(identity: identity)
                 expired_count = 0
 
-                prediction_store.pending.each do |pred|
+                store.pending.each do |pred|
                   age = Time.now.utc - pred[:created_at]
                   next unless age > pred[:horizon]
 
-                  prediction_store.resolve(pred[:prediction_id], outcome: :expired, actual: nil)
+                  store.resolve(pred[:prediction_id], outcome: :expired, actual: nil)
                   expired_count += 1
                 end
 
-                remaining = prediction_store.pending.size
+                remaining = store.pending.size
                 log.debug "[prediction] expire sweep: expired=#{expired_count} remaining=#{remaining}"
 
                 { expired_count: expired_count, remaining_pending: remaining }
               end
 
-              def get_prediction(prediction_id:, **)
-                pred = prediction_store.get(prediction_id)
+              def get_prediction(prediction_id:, identity: nil, **)
+                store = prediction_store(identity: identity)
+                pred = store.get(prediction_id)
                 pred ? { found: true, prediction: pred } : { found: false }
               end
 
-              private
-
-              def prediction_store
-                @prediction_store ||= Helpers::PredictionStore.new
+              def erase_partner!(identity:, **)
+                store = prediction_store(identity: identity)
+                result = store.erase_partner!(identity: identity)
+                log.info "[prediction] erased partner identity=#{identity}"
+                result
               end
 
+              private
+
               def estimate_confidence(mode, context)
                 base = case mode
                        when :fault_localization then 0.7

data/lib/legion/extensions/agentic/inference/version.rb

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Inference
-        VERSION = '0.1.9'
+        VERSION = '0.1.10'
       end
     end
   end

data/spec/legion/extensions/agentic/inference/prediction/helpers/prediction_store_identity_spec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Prediction::Helpers::PredictionStore do
+  let(:store_x) { described_class.new(identity: 'partner-X') }
+  let(:store_y) { described_class.new(identity: 'partner-Y') }
+
+  let(:basic_prediction) do
+    {
+      mode:        :fault_localization,
+      confidence:  0.75,
+      description: 'disk latency spike incoming',
+      status:      :pending
+    }
+  end
+
+  describe 'identity isolation — reads for X never see Y data' do
+    it 'stores predictions under the correct identity' do
+      id_x = store_x.store(basic_prediction.dup)
+      expect(store_x.get(id_x)).not_to be_nil
+      expect(store_y.get(id_x)).to be_nil
+    end
+
+    it 'X accuracy is independent of Y outcomes' do
+      3.times do
+        id = store_x.store(basic_prediction.dup)
+        store_x.resolve(id, outcome: :correct)
+      end
+      3.times do
+        id = store_y.store(basic_prediction.dup)
+        store_y.resolve(id, outcome: :incorrect)
+      end
+
+      expect(store_x.accuracy).to eq(1.0)
+      expect(store_y.accuracy).to eq(0.0)
+    end
+
+    it 'X pending predictions do not include Y predictions' do
+      store_x.store(basic_prediction.dup)
+      id_y = store_y.store(basic_prediction.dup)
+      store_y.resolve(id_y, outcome: :correct)
+
+      expect(store_x.pending.size).to eq(1)
+      expect(store_y.pending.size).to eq(0)
+    end
+
+    it 'X count is independent of Y count' do
+      3.times { store_x.store(basic_prediction.dup) }
+      5.times { store_y.store(basic_prediction.dup) }
+
+      expect(store_x.count).to eq(3)
+      expect(store_y.count).to eq(5)
+    end
+  end
+
+  describe '#identity' do
+    it 'exposes the identity it was initialized with' do
+      expect(store_x.identity).to eq('partner-X')
+    end
+  end
+
+  describe '#erase_partner!' do
+    it 'removes all predictions for the identity' do
+      3.times { store_x.store(basic_prediction.dup) }
+      store_x.erase_partner!(identity: 'partner-X')
+      expect(store_x.count).to eq(0)
+    end
+
+    it 'removes all outcomes for the identity' do
+      id = store_x.store(basic_prediction.dup)
+      store_x.resolve(id, outcome: :correct)
+      store_x.erase_partner!(identity: 'partner-X')
+      expect(store_x.outcomes).to be_empty
+    end
+
+    it 'does not touch a different identity store' do
+      id_x = store_x.store(basic_prediction.dup)
+      store_x.resolve(id_x, outcome: :correct)
+
+      3.times { store_y.store(basic_prediction.dup) }
+      store_x.erase_partner!(identity: 'partner-X')
+
+      expect(store_y.count).to eq(3)
+    end
+
+    it 'returns a confirmation hash' do
+      result = store_x.erase_partner!(identity: 'partner-X')
+      expect(result).to include(erased: true, identity: 'partner-X')
+    end
+
+    it 'raises ArgumentError when identity does not match own identity' do
+      expect { store_x.erase_partner!(identity: 'partner-Y') }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/prediction/runners/prediction_identity_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/prediction/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Prediction::Runners::Prediction do
+  let(:client) { Legion::Extensions::Agentic::Inference::Prediction::Client.new }
+
+  describe 'per-identity isolation' do
+    it 'predictions for identity X are not visible to identity Y' do
+      result_x = client.predict(mode: :fault_localization, identity: 'alice')
+      result_y = client.get_prediction(prediction_id: result_x[:prediction_id], identity: 'bob')
+      expect(result_y[:found]).to be false
+    end
+
+    it 'accuracy for X is independent of Y outcomes' do
+      3.times do
+        pred = client.predict(mode: :fault_localization, identity: 'alice')
+        client.resolve_prediction(prediction_id: pred[:prediction_id], outcome: :correct, identity: 'alice')
+      end
+      3.times do
+        pred = client.predict(mode: :fault_localization, identity: 'bob')
+        client.resolve_prediction(prediction_id: pred[:prediction_id], outcome: :incorrect, identity: 'bob')
+      end
+
+      acc_alice = client.prediction_accuracy(identity: 'alice')
+      acc_bob = client.prediction_accuracy(identity: 'bob')
+
+      expect(acc_alice[:accuracy]).to eq(1.0)
+      expect(acc_bob[:accuracy]).to eq(0.0)
+    end
+
+    it 'pending count for X does not include Y predictions' do
+      client.predict(mode: :fault_localization, identity: 'alice')
+      pred_bob = client.predict(mode: :fault_localization, identity: 'bob')
+      client.resolve_prediction(prediction_id: pred_bob[:prediction_id], outcome: :correct, identity: 'bob')
+
+      alice_pending = client.pending_predictions(identity: 'alice')
+      bob_pending = client.pending_predictions(identity: 'bob')
+
+      expect(alice_pending[:count]).to eq(1)
+      expect(bob_pending[:count]).to eq(0)
+    end
+  end
+
+  describe '#erase_partner!' do
+    it 'removes all predictions and outcomes for the identity' do
+      3.times do
+        pred = client.predict(mode: :fault_localization, identity: 'alice')
+        client.resolve_prediction(prediction_id: pred[:prediction_id], outcome: :correct, identity: 'alice')
+      end
+
+      result = client.erase_partner!(identity: 'alice')
+      expect(result[:erased]).to be true
+      expect(result[:identity]).to eq('alice')
+
+      expect(client.pending_predictions(identity: 'alice')[:count]).to eq(0)
+      expect(client.prediction_accuracy(identity: 'alice')[:total_outcomes]).to eq(0)
+    end
+
+    it 'does not affect a different identity after erase' do
+      3.times { client.predict(mode: :fault_localization, identity: 'bob') }
+      client.erase_partner!(identity: 'alice')
+
+      expect(client.pending_predictions(identity: 'bob')[:count]).to eq(3)
+    end
+  end
+
+  describe '#client responds to erase_partner!' do
+    it 'responds to erase_partner!' do
+      expect(client).to respond_to(:erase_partner!)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-agentic-inference
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.10
 platform: ruby
 authors:
 - Esity
@@ -483,7 +483,9 @@ files:
 - spec/legion/extensions/agentic/inference/prediction/actors/expire_predictions_spec.rb
 - spec/legion/extensions/agentic/inference/prediction/client_spec.rb
 - spec/legion/extensions/agentic/inference/prediction/helpers/modes_spec.rb
+- spec/legion/extensions/agentic/inference/prediction/helpers/prediction_store_identity_spec.rb
 - spec/legion/extensions/agentic/inference/prediction/helpers/prediction_store_spec.rb
+- spec/legion/extensions/agentic/inference/prediction/runners/prediction_identity_spec.rb
 - spec/legion/extensions/agentic/inference/prediction/runners/prediction_spec.rb
 - spec/legion/extensions/agentic/inference/predictive_coding/client_spec.rb
 - spec/legion/extensions/agentic/inference/predictive_coding/helpers/generative_model_spec.rb