lex-agentic-inference 0.1.0

data/lib/legion/extensions/agentic/inference/predictive_processing/helpers/predictive_processor.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module PredictiveProcessing
+          module Helpers
+            class PredictiveProcessor
+              include Constants
+
+              attr_reader :models
+
+              def initialize
+                @models = {}
+              end
+
+              def add_model(domain:)
+                return { added: false, reason: :limit_reached } if @models.size >= MAX_MODELS
+                return { added: false, reason: :already_exists } if @models.key?(domain)
+
+                model = GenerativeModel.new(domain: domain)
+                @models[domain] = model
+                { added: true, domain: domain, model_id: model.id }
+              end
+
+              def predict(domain:, context: {})
+                model = find_or_create(domain)
+                model.predict(context: context)
+              end
+
+              def observe(domain:, actual:, predicted:)
+                model = @models[domain]
+                return { observed: false, reason: :domain_not_found } unless model
+
+                error = model.observe(actual: actual, predicted: predicted)
+                mode  = inference_mode(domain)
+
+                model.update_model(error: error) if %i[perceptual hybrid].include?(mode)
+
+                {
+                  observed:         true,
+                  domain:           domain,
+                  prediction_error: error,
+                  inference_mode:   mode,
+                  free_energy:      model.free_energy,
+                  state:            model.state
+                }
+              end
+
+              def inference_mode(domain)
+                model = @models[domain]
+                return :perceptual unless model
+
+                fe = model.free_energy
+                determine_mode(fe, model.precision)
+              end
+
+              def free_energy_for(domain)
+                model = @models[domain]
+                model&.free_energy
+              end
+
+              def global_free_energy
+                return 0.0 if @models.empty?
+
+                total = @models.values.sum(&:free_energy)
+                total / @models.size
+              end
+
+              def precision_weight(domain)
+                model = @models[domain]
+                model ? model.precision : DEFAULT_PRECISION
+              end
+
+              def models_needing_update
+                @models.select { |_d, m| m.surprised? }.transform_values(&:to_h)
+              end
+
+              def stable_models
+                @models.select { |_d, m| m.stable? }.transform_values(&:to_h)
+              end
+
+              def active_inference_candidates
+                @models.select { |_d, m| m.free_energy > ACTIVE_INFERENCE_THRESHOLD }
+                       .keys
+              end
+
+              def tick
+                @models.each_value(&:decay)
+              end
+
+              def to_h
+                {
+                  model_count:              @models.size,
+                  global_free_energy:       global_free_energy,
+                  models_needing_update:    models_needing_update.size,
+                  stable_model_count:       stable_models.size,
+                  active_inference_domains: active_inference_candidates.size,
+                  models:                   @models.transform_values(&:to_h)
+                }
+              end
+
+              private
+
+              def find_or_create(domain)
+                @models[domain] ||= begin
+                  model           = GenerativeModel.new(domain: domain)
+                  @models[domain] = model if @models.size < MAX_MODELS
+                  model
+                end
+              end
+
+              def determine_mode(free_energy, precision)
+                if free_energy > FREE_ENERGY_THRESHOLD && precision >= ACTIVE_INFERENCE_THRESHOLD
+                  :hybrid
+                elsif free_energy > ACTIVE_INFERENCE_THRESHOLD
+                  :active
+                else
+                  :perceptual
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module PredictiveProcessing
+          module Runners
+            module PredictiveProcessing
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def add_generative_model(domain:, **)
+                return { added: false, reason: :missing_domain } if domain.nil? || domain.to_s.strip.empty?
+
+                result = default_processor.add_model(domain: domain.to_sym)
+                Legion::Logging.debug "[predictive_processing] add_model domain=#{domain} added=#{result[:added]}"
+                result
+              end
+
+              def predict_from_model(domain:, context: {}, **)
+                return { predicted: false, reason: :missing_domain } if domain.nil?
+
+                prediction = default_processor.predict(domain: domain.to_sym, context: context)
+                Legion::Logging.debug "[predictive_processing] predict domain=#{domain} " \
+                                      "expected=#{prediction[:expected_value]&.round(3)}"
+                { predicted: true, domain: domain, prediction: prediction }
+              end
+
+              def observe_outcome(domain:, actual:, predicted:, **)
+                return { observed: false, reason: :missing_domain } if domain.nil?
+
+                result = default_processor.observe(
+                  domain:    domain.to_sym,
+                  actual:    actual,
+                  predicted: predicted
+                )
+                log_observe(domain, result)
+                result
+              end
+
+              def inference_mode(domain:, **)
+                return { mode: nil, reason: :missing_domain } if domain.nil?
+
+                mode = default_processor.inference_mode(domain.to_sym)
+                Legion::Logging.debug "[predictive_processing] inference_mode domain=#{domain} mode=#{mode}"
+                { domain: domain, mode: mode }
+              end
+
+              def free_energy(domain: nil, **)
+                if domain
+                  fe = default_processor.free_energy_for(domain.to_sym)
+                  return { domain: domain, free_energy: nil, reason: :domain_not_found } if fe.nil?
+
+                  { domain: domain, free_energy: fe }
+                else
+                  { global_free_energy: default_processor.global_free_energy }
+                end
+              end
+
+              def models_needing_update(**)
+                needing = default_processor.models_needing_update
+                Legion::Logging.debug "[predictive_processing] models_needing_update count=#{needing.size}"
+                { count: needing.size, models: needing }
+              end
+
+              def active_inference_candidates(**)
+                candidates = default_processor.active_inference_candidates
+                Legion::Logging.debug "[predictive_processing] active_inference_candidates count=#{candidates.size}"
+                { count: candidates.size, domains: candidates }
+              end
+
+              def update_predictive_processing(**)
+                default_processor.tick
+                Legion::Logging.debug '[predictive_processing] tick: precision decayed on all models'
+                { ticked: true, model_count: default_processor.models.size }
+              end
+
+              def predictive_processing_stats(**)
+                stats = default_processor.to_h
+                Legion::Logging.debug "[predictive_processing] stats global_fe=#{stats[:global_free_energy]&.round(3)}"
+                { success: true, stats: stats }
+              end
+
+              private
+
+              def default_processor
+                @default_processor ||= Helpers::PredictiveProcessor.new
+              end
+
+              def log_observe(domain, result)
+                return unless result[:observed]
+
+                Legion::Logging.debug "[predictive_processing] observe domain=#{domain} " \
+                                      "error=#{result[:prediction_error]&.round(3)} " \
+                                      "mode=#{result[:inference_mode]}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module PredictiveProcessing
+          VERSION = '0.1.0'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/predictive_processing/version'
+require 'legion/extensions/agentic/inference/predictive_processing/helpers/constants'
+require 'legion/extensions/agentic/inference/predictive_processing/helpers/generative_model'
+require 'legion/extensions/agentic/inference/predictive_processing/helpers/predictive_processor'
+require 'legion/extensions/agentic/inference/predictive_processing/runners/predictive_processing'
+require 'legion/extensions/agentic/inference/predictive_processing/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module PredictiveProcessing
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/reality_testing/helpers/constants'
+require 'legion/extensions/agentic/inference/reality_testing/helpers/belief'
+require 'legion/extensions/agentic/inference/reality_testing/helpers/reality_engine'
+require 'legion/extensions/agentic/inference/reality_testing/runners/reality_testing'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module RealityTesting
+          class Client
+            include Runners::RealityTesting
+
+            def initialize(**)
+              @reality_engine = Helpers::RealityEngine.new
+            end
+
+            private
+
+            attr_reader :reality_engine
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/reality_testing/helpers/belief.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module RealityTesting
+          module Helpers
+            class Belief
+              include Constants
+
+              attr_reader :id, :claim, :domain, :confidence, :evidence_count,
+                          :confirming_count, :disconfirming_count, :created_at, :last_tested_at
+
+              def initialize(id:, claim:, domain: :general, confidence: Constants::DEFAULT_CONFIDENCE)
+                @id                  = id
+                @claim               = claim
+                @domain              = domain
+                @confidence          = confidence.clamp(0.0, 1.0)
+                @evidence_count      = 0
+                @confirming_count    = 0
+                @disconfirming_count = 0
+                @created_at          = Time.now.utc
+                @last_tested_at      = nil
+              end
+
+              def test_with_evidence!(evidence_type:, weight: 0.1)
+                raise ArgumentError, "unknown evidence_type: #{evidence_type}" unless Constants::EVIDENCE_TYPES.include?(evidence_type)
+
+                @evidence_count   += 1
+                @last_tested_at    = Time.now.utc
+
+                case evidence_type
+                when :confirming
+                  @confirming_count += 1
+                  @confidence = (@confidence + (Constants::CONFIDENCE_BOOST * weight * 10)).clamp(0.0, 1.0)
+                when :disconfirming
+                  @disconfirming_count += 1
+                  @confidence = (@confidence - (Constants::CONFIDENCE_PENALTY * weight * 10)).clamp(0.0, 1.0)
+                when :neutral
+                  # no confidence change
+                when :ambiguous
+                  delta = @confidence - 0.5
+                  @confidence = (@confidence - (delta * 0.1)).clamp(0.0, 1.0)
+                end
+
+                self
+              end
+
+              def confidence_label
+                Constants::CONFIDENCE_LABELS.find { |entry| entry[:range].cover?(@confidence) }&.fetch(:label) || :rejected
+              end
+
+              def validity
+                total = @confirming_count + @disconfirming_count
+                return 0.5 if total.zero?
+
+                @confirming_count.to_f / total
+              end
+
+              def validity_label
+                v = validity
+                Constants::VALIDITY_LABELS.find { |entry| entry[:range].cover?(v) }&.fetch(:label) || :refuted
+              end
+
+              def needs_testing?
+                @confidence.between?(0.3, 0.7)
+              end
+
+              def decay!
+                @confidence = (@confidence - Constants::CONFIDENCE_DECAY).clamp(0.0, 1.0)
+                self
+              end
+
+              def to_h
+                {
+                  id:                  @id,
+                  claim:               @claim,
+                  domain:              @domain,
+                  confidence:          @confidence,
+                  confidence_label:    confidence_label,
+                  evidence_count:      @evidence_count,
+                  confirming_count:    @confirming_count,
+                  disconfirming_count: @disconfirming_count,
+                  validity:            validity.round(3),
+                  validity_label:      validity_label,
+                  needs_testing:       needs_testing?,
+                  created_at:          @created_at,
+                  last_tested_at:      @last_tested_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/reality_testing/helpers/constants.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module RealityTesting
+          module Helpers
+            module Constants
+              MAX_BELIEFS   = 300
+              MAX_EVIDENCE  = 500
+
+              DEFAULT_CONFIDENCE  = 0.5
+              CONFIDENCE_BOOST    = 0.1
+              CONFIDENCE_PENALTY  = 0.15
+              CONFIDENCE_DECAY    = 0.02
+
+              CONFIDENCE_LABELS = [
+                { range: (0.85..1.0), label: :certain },
+                { range: (0.65...0.85), label: :confident  },
+                { range: (0.35...0.65), label: :tentative  },
+                { range: (0.15...0.35), label: :doubtful   },
+                { range: (0.0...0.15),  label: :rejected   }
+              ].freeze
+
+              EVIDENCE_TYPES = %i[confirming disconfirming neutral ambiguous].freeze
+
+              VALIDITY_LABELS = [
+                { range: (0.75..1.0),   label: :validated    },
+                { range: (0.55...0.75), label: :supported    },
+                { range: (0.35...0.55), label: :uncertain    },
+                { range: (0.15...0.35), label: :questionable },
+                { range: (0.0...0.15),  label: :refuted      }
+              ].freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/reality_testing/helpers/reality_engine.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module RealityTesting
+          module Helpers
+            class RealityEngine
+              def initialize
+                @beliefs     = {}
+                @next_id     = 1
+              end
+
+              def create_belief(claim:, domain: :general, confidence: Constants::DEFAULT_CONFIDENCE)
+                return { created: false, reason: :at_capacity } if @beliefs.size >= Constants::MAX_BELIEFS
+
+                id = "belief_#{@next_id}"
+                @next_id += 1
+                belief = Belief.new(id: id, claim: claim, domain: domain, confidence: confidence)
+                @beliefs[id] = belief
+                Legion::Logging.debug "[reality_testing] create_belief id=#{id} domain=#{domain} confidence=#{confidence.round(2)}"
+                { created: true, belief: belief.to_h }
+              end
+
+              def test_belief(belief_id:, evidence_type:, weight: 0.1)
+                belief = @beliefs[belief_id]
+                return { tested: false, reason: :not_found } unless belief
+
+                belief.test_with_evidence!(evidence_type: evidence_type, weight: weight)
+                Legion::Logging.debug "[reality_testing] test_belief id=#{belief_id} evidence=#{evidence_type} confidence=#{belief.confidence.round(2)}"
+                { tested: true, belief: belief.to_h }
+              end
+
+              def beliefs_needing_testing
+                @beliefs.values.select(&:needs_testing?)
+              end
+
+              def strongest_beliefs(limit: 10)
+                @beliefs.values
+                        .sort_by { |b| -b.confidence }
+                        .first(limit)
+              end
+
+              def weakest_beliefs(limit: 10)
+                @beliefs.values
+                        .sort_by(&:confidence)
+                        .first(limit)
+              end
+
+              def beliefs_by_domain(domain:)
+                @beliefs.values.select { |b| b.domain == domain }
+              end
+
+              def overall_reality_coherence
+                return 0.0 if @beliefs.empty?
+
+                total = @beliefs.values.sum(&:validity)
+                total / @beliefs.size
+              end
+
+              def decay_all
+                @beliefs.each_value(&:decay!)
+                @beliefs.size
+              end
+
+              def prune_rejected
+                before = @beliefs.size
+                @beliefs.delete_if { |_id, b| b.confidence < 0.1 }
+                pruned = before - @beliefs.size
+                Legion::Logging.debug "[reality_testing] prune_rejected pruned=#{pruned} remaining=#{@beliefs.size}"
+                pruned
+              end
+
+              def reality_report
+                domains = @beliefs.values.group_by(&:domain)
+                {
+                  total_beliefs:   @beliefs.size,
+                  coherence:       overall_reality_coherence.round(3),
+                  needing_testing: beliefs_needing_testing.size,
+                  domains:         domains.transform_values(&:size),
+                  strongest_claim: @beliefs.values.max_by(&:confidence)&.claim,
+                  weakest_claim:   @beliefs.values.min_by(&:confidence)&.claim
+                }
+              end
+
+              def to_h
+                {
+                  belief_count: @beliefs.size,
+                  coherence:    overall_reality_coherence.round(3),
+                  beliefs:      @beliefs.values.map(&:to_h)
+                }
+              end
+
+              def size
+                @beliefs.size
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module RealityTesting
+          module Runners
+            module RealityTesting
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def create_belief(claim:, domain: :general, confidence: nil, **)
+                conf   = confidence || Helpers::Constants::DEFAULT_CONFIDENCE
+                result = reality_engine.create_belief(claim: claim, domain: domain, confidence: conf)
+                Legion::Logging.info "[reality_testing] create_belief claim=#{claim[0, 60]} domain=#{domain}"
+                result
+              end
+
+              def test_belief(belief_id:, evidence_type:, weight: 0.1, **)
+                etype = evidence_type.to_sym
+                reality_engine.test_belief(belief_id: belief_id, evidence_type: etype, weight: weight)
+              end
+
+              def get_belief(belief_id:, **)
+                engine = reality_engine
+                belief = engine.instance_variable_get(:@beliefs)[belief_id]
+                return { found: false, belief_id: belief_id } unless belief
+
+                { found: true, belief: belief.to_h }
+              end
+
+              def beliefs_needing_testing(**)
+                beliefs = reality_engine.beliefs_needing_testing
+                Legion::Logging.debug "[reality_testing] needs_testing count=#{beliefs.size}"
+                { count: beliefs.size, beliefs: beliefs.map(&:to_h) }
+              end
+
+              def strongest_beliefs(limit: 10, **)
+                beliefs = reality_engine.strongest_beliefs(limit: limit)
+                { count: beliefs.size, beliefs: beliefs.map(&:to_h) }
+              end
+
+              def weakest_beliefs(limit: 10, **)
+                beliefs = reality_engine.weakest_beliefs(limit: limit)
+                { count: beliefs.size, beliefs: beliefs.map(&:to_h) }
+              end
+
+              def beliefs_by_domain(domain:, **)
+                beliefs = reality_engine.beliefs_by_domain(domain: domain.to_sym)
+                { domain: domain, count: beliefs.size, beliefs: beliefs.map(&:to_h) }
+              end
+
+              def overall_coherence(**)
+                coherence = reality_engine.overall_reality_coherence
+                Legion::Logging.debug "[reality_testing] coherence=#{coherence.round(3)}"
+                { coherence: coherence.round(3) }
+              end
+
+              def decay_beliefs(**)
+                count = reality_engine.decay_all
+                Legion::Logging.debug "[reality_testing] decay_all count=#{count}"
+                { decayed: count }
+              end
+
+              def prune_rejected_beliefs(**)
+                pruned = reality_engine.prune_rejected
+                { pruned: pruned }
+              end
+
+              def reality_report(**)
+                reality_engine.reality_report
+              end
+
+              def reality_status(**)
+                {
+                  total_beliefs:   reality_engine.size,
+                  coherence:       reality_engine.overall_reality_coherence.round(3),
+                  needing_testing: reality_engine.beliefs_needing_testing.size
+                }
+              end
+
+              private
+
+              def reality_engine
+                @reality_engine ||= Helpers::RealityEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module RealityTesting
+          VERSION = '0.1.0'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/reality_testing/version'
+require 'legion/extensions/agentic/inference/reality_testing/helpers/constants'
+require 'legion/extensions/agentic/inference/reality_testing/helpers/belief'
+require 'legion/extensions/agentic/inference/reality_testing/helpers/reality_engine'
+require 'legion/extensions/agentic/inference/reality_testing/runners/reality_testing'
+require 'legion/extensions/agentic/inference/reality_testing/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module RealityTesting
+        end
+      end
+    end
+  end
+end