lex-agentic-inference 0.1.0

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/schema/helpers/constants'
+require 'legion/extensions/agentic/inference/schema/helpers/causal_relation'
+require 'legion/extensions/agentic/inference/schema/helpers/world_model'
+require 'legion/extensions/agentic/inference/schema/runners/schema'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Schema
+          class Client
+            include Runners::Schema
+
+            attr_reader :world_model
+
+            def initialize(world_model: nil, **)
+              @world_model = world_model || Helpers::WorldModel.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/schema/helpers/causal_relation.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Schema
+          module Helpers
+            class CausalRelation
+              attr_reader :id, :cause, :effect, :relation_type, :confidence,
+                          :evidence_count, :created_at, :updated_at
+
+              def initialize(cause:, effect:, relation_type:, confidence: 0.5)
+                @id             = SecureRandom.uuid
+                @cause          = cause
+                @effect         = effect
+                @relation_type  = relation_type
+                @confidence     = confidence.clamp(0.0, 1.0)
+                @evidence_count = 1
+                @created_at     = Time.now.utc
+                @updated_at     = Time.now.utc
+              end
+
+              def reinforce(amount = Constants::REINFORCEMENT_BONUS)
+                @confidence = [@confidence + amount, 1.0].min
+                @evidence_count += 1
+                @updated_at = Time.now.utc
+              end
+
+              def weaken(amount = Constants::CONTRADICTION_PENALTY)
+                @confidence = [@confidence - amount, 0.0].max
+                @updated_at = Time.now.utc
+              end
+
+              def decay
+                @confidence = [@confidence - Constants::DECAY_RATE, 0.0].max
+              end
+
+              def established?
+                @confidence >= Constants::CONFIDENCE_LEVELS[:established]
+              end
+
+              def speculative?
+                @confidence <= Constants::CONFIDENCE_LEVELS[:speculative]
+              end
+
+              def prunable?
+                @confidence < Constants::PRUNE_THRESHOLD
+              end
+
+              def to_h
+                {
+                  id:             @id,
+                  cause:          @cause,
+                  effect:         @effect,
+                  relation_type:  @relation_type,
+                  confidence:     @confidence.round(4),
+                  evidence_count: @evidence_count,
+                  established:    established?
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Schema
+          module Helpers
+            module Constants
+              RELATION_TYPES = %i[
+                causes
+                prevents
+                enables
+                requires
+                correlates
+                contradicts
+              ].freeze
+
+              CONFIDENCE_LEVELS = {
+                established: 0.9,
+                strong:      0.7,
+                moderate:    0.5,
+                weak:        0.3,
+                speculative: 0.1
+              }.freeze
+
+              SCHEMA_ALPHA = 0.12
+
+              MAX_SCHEMAS = 500
+
+              MAX_RELATIONS_PER_SCHEMA = 50
+
+              REINFORCEMENT_BONUS = 0.05
+
+              CONTRADICTION_PENALTY = 0.15
+
+              DECAY_RATE = 0.005
+
+              PRUNE_THRESHOLD = 0.1
+
+              MAX_COUNTERFACTUAL_DEPTH = 5
+
+              MAX_EXPLANATION_CHAIN = 10
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/schema/helpers/world_model.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Schema
+          module Helpers
+            class WorldModel
+              attr_reader :relations, :domains
+
+              def initialize
+                @relations = {}
+                @domains   = Hash.new { |h, k| h[k] = [] }
+              end
+
+              def add_relation(cause:, effect:, relation_type:, confidence: 0.5)
+                return nil unless Constants::RELATION_TYPES.include?(relation_type)
+
+                key = relation_key(cause, effect, relation_type)
+                if @relations.key?(key)
+                  @relations[key].reinforce
+                else
+                  @relations[key] = CausalRelation.new(cause: cause, effect: effect, relation_type: relation_type, confidence: confidence)
+                  index_domains(cause, effect, key)
+                  trim_relations
+                end
+                @relations[key]
+              end
+
+              def weaken_relation(cause:, effect:, relation_type:)
+                key = relation_key(cause, effect, relation_type)
+                relation = @relations[key]
+                return nil unless relation
+
+                relation.weaken
+                prune_if_needed(key)
+                relation
+              end
+
+              def find_effects(cause)
+                keys = @domains[cause] || []
+                keys.filter_map { |k| @relations[k] }.select { |r| r.cause == cause }
+              end
+
+              def find_causes(effect)
+                keys = @domains[effect] || []
+                keys.filter_map { |k| @relations[k] }.select { |r| r.effect == effect }
+              end
+
+              def explain(outcome, max_depth: Constants::MAX_EXPLANATION_CHAIN)
+                chain = []
+                visited = Set.new
+                build_explanation_chain(outcome, chain, visited, max_depth)
+                chain
+              end
+
+              def counterfactual(cause, max_depth: Constants::MAX_COUNTERFACTUAL_DEPTH)
+                affected = []
+                visited  = Set.new
+                propagate_counterfactual(cause, affected, visited, max_depth)
+                affected
+              end
+
+              def contradictions
+                @relations.values.each_with_object([]) do |rel, result|
+                  next unless rel.relation_type == :causes
+
+                  opposite = @relations[relation_key(rel.cause, rel.effect, :prevents)]
+                  next unless opposite
+
+                  result << {
+                    cause:               rel.cause,
+                    effect:              rel.effect,
+                    causes_confidence:   rel.confidence.round(4),
+                    prevents_confidence: opposite.confidence.round(4)
+                  }
+                end
+              end
+
+              def decay_all
+                @relations.each_value(&:decay)
+                prune_weak
+              end
+
+              def relation_count
+                @relations.size
+              end
+
+              def domain_count
+                all_entities = @relations.values.flat_map { |r| [r.cause, r.effect] }
+                all_entities.uniq.size
+              end
+
+              def established_relations
+                @relations.values.select(&:established?)
+              end
+
+              def to_h
+                {
+                  relation_count:      relation_count,
+                  domain_count:        domain_count,
+                  established_count:   established_relations.size,
+                  contradiction_count: contradictions.size
+                }
+              end
+
+              private
+
+              def relation_key(cause, effect, relation_type)
+                "#{cause}->#{relation_type}->#{effect}"
+              end
+
+              def index_domains(cause, effect, key)
+                @domains[cause] << key
+                @domains[effect] << key
+              end
+
+              def build_explanation_chain(outcome, chain, visited, depth)
+                return if depth <= 0 || visited.include?(outcome)
+
+                visited.add(outcome)
+                causes = find_causes(outcome).sort_by { |r| -r.confidence }
+                causes.first(3).each do |rel|
+                  chain << rel.to_h
+                  build_explanation_chain(rel.cause, chain, visited, depth - 1)
+                end
+              end
+
+              def propagate_counterfactual(cause, affected, visited, depth)
+                return if depth <= 0 || visited.include?(cause)
+
+                visited.add(cause)
+                effects = find_effects(cause).sort_by { |r| -r.confidence }
+                effects.each do |rel|
+                  affected << { effect: rel.effect, relation: rel.relation_type, confidence: rel.confidence.round(4) }
+                  propagate_counterfactual(rel.effect, affected, visited, depth - 1)
+                end
+              end
+
+              def prune_if_needed(key)
+                relation = @relations[key]
+                return unless relation&.prunable?
+
+                remove_relation(key)
+              end
+
+              def prune_weak
+                prunable = @relations.select { |_, r| r.prunable? }.keys
+                prunable.each { |key| remove_relation(key) }
+              end
+
+              def remove_relation(key)
+                rel = @relations.delete(key)
+                return unless rel
+
+                @domains[rel.cause]&.delete(key)
+                @domains[rel.effect]&.delete(key)
+              end
+
+              def trim_relations
+                return if @relations.size <= Constants::MAX_SCHEMAS
+
+                weakest = @relations.sort_by { |_, r| r.confidence }
+                weakest.first(@relations.size - Constants::MAX_SCHEMAS).each { |k, _| remove_relation(k) } # rubocop:disable Style/HashEachMethods
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Schema
+          module Runners
+            module Schema
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def update_schema(tick_results: {}, **)
+                extract_prediction_outcomes(tick_results)
+                world_model.decay_all
+
+                Legion::Logging.debug "[schema] relations=#{world_model.relation_count} " \
+                                      "domains=#{world_model.domain_count} established=#{world_model.established_relations.size}"
+
+                world_model.to_h
+              end
+
+              def learn_relation(cause:, effect:, relation_type:, confidence: 0.5, **)
+                relation_sym = relation_type.to_sym
+                result = world_model.add_relation(cause: cause, effect: effect, relation_type: relation_sym, confidence: confidence)
+                return { success: false, error: 'invalid relation type' } unless result
+
+                Legion::Logging.info "[schema] learned: #{cause} #{relation_sym} #{effect} (#{result.confidence.round(2)})"
+                { success: true, relation: result.to_h }
+              end
+
+              def weaken_relation(cause:, effect:, relation_type:, **)
+                result = world_model.weaken_relation(cause: cause, effect: effect, relation_type: relation_type.to_sym)
+                return { success: false, error: 'relation not found' } unless result
+
+                Legion::Logging.debug "[schema] weakened: #{cause} #{relation_type} #{effect}"
+                { success: true, relation: result.to_h }
+              end
+
+              def explain(outcome:, **)
+                chain = world_model.explain(outcome)
+                Legion::Logging.debug "[schema] explanation for #{outcome}: #{chain.size} links"
+                { outcome: outcome, chain: chain, depth: chain.size }
+              end
+
+              def counterfactual(cause:, **)
+                affected = world_model.counterfactual(cause)
+                Legion::Logging.debug "[schema] counterfactual for #{cause}: #{affected.size} effects"
+                { cause: cause, affected: affected, impact: affected.size }
+              end
+
+              def find_effects(cause:, **)
+                effects = world_model.find_effects(cause).map(&:to_h)
+                { cause: cause, effects: effects, count: effects.size }
+              end
+
+              def find_causes(effect:, **)
+                causes = world_model.find_causes(effect).map(&:to_h)
+                { effect: effect, causes: causes, count: causes.size }
+              end
+
+              def contradictions(**)
+                result = world_model.contradictions
+                Legion::Logging.debug "[schema] contradictions: #{result.size}"
+                { contradictions: result, count: result.size }
+              end
+
+              def schema_stats(**)
+                Legion::Logging.debug '[schema] stats'
+                world_model.to_h.merge(
+                  top_relations: world_model.established_relations.first(10).map(&:to_h)
+                )
+              end
+
+              private
+
+              def world_model
+                @world_model ||= Helpers::WorldModel.new
+              end
+
+              def extract_prediction_outcomes(tick_results)
+                predictions = tick_results.dig(:prediction_engine, :resolved)
+                return unless predictions.is_a?(Array)
+
+                predictions.each do |pred|
+                  next unless pred[:domain] && pred[:outcome_domain]
+
+                  if pred[:accurate]
+                    world_model.add_relation(cause: pred[:domain], effect: pred[:outcome_domain], relation_type: :causes, confidence: 0.6)
+                  else
+                    world_model.weaken_relation(cause: pred[:domain], effect: pred[:outcome_domain], relation_type: :causes)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/schema/version'
+require 'legion/extensions/agentic/inference/schema/helpers/constants'
+require 'legion/extensions/agentic/inference/schema/helpers/causal_relation'
+require 'legion/extensions/agentic/inference/schema/helpers/world_model'
+require 'legion/extensions/agentic/inference/schema/runners/schema'
+require 'legion/extensions/agentic/inference/schema/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Schema
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/uncertainty_tolerance/helpers/constants'
+require 'legion/extensions/agentic/inference/uncertainty_tolerance/helpers/decision'
+require 'legion/extensions/agentic/inference/uncertainty_tolerance/helpers/tolerance_engine'
+require 'legion/extensions/agentic/inference/uncertainty_tolerance/runners/uncertainty_tolerance'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module UncertaintyTolerance
+          class Client
+            include Runners::UncertaintyTolerance
+
+            def initialize(**)
+              @engine = Helpers::ToleranceEngine.new
+            end
+
+            private
+
+            attr_reader :engine
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module UncertaintyTolerance
+          module Helpers
+            module Constants
+              TOLERANCE_LABELS = {
+                (0.8..)     => :highly_tolerant,
+                (0.6...0.8) => :tolerant,
+                (0.4...0.6) => :moderate,
+                (0.2...0.4) => :intolerant,
+                (..0.2)     => :highly_intolerant
+              }.freeze
+
+              DECISION_TYPES = %i[certain probable uncertain ambiguous unknown].freeze
+
+              CERTAINTY_THRESHOLDS = {
+                certain:   0.9,
+                probable:  0.7,
+                uncertain: 0.5,
+                ambiguous: 0.3,
+                unknown:   0.0
+              }.freeze
+
+              MAX_DECISIONS        = 300
+              MAX_HISTORY          = 500
+              DEFAULT_TOLERANCE    = 0.5
+              TOLERANCE_FLOOR      = 0.0
+              TOLERANCE_CEILING    = 1.0
+              ADAPTATION_RATE      = 0.05
+              POSITIVE_OUTCOME_BOOST   = 0.03
+              NEGATIVE_OUTCOME_PENALTY = 0.05
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/uncertainty_tolerance/helpers/decision.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module UncertaintyTolerance
+          module Helpers
+            class Decision
+              attr_reader :id, :description, :domain, :certainty_level,
+                          :tolerance_at_time, :acted_despite_uncertainty, :created_at
+              attr_accessor :actual_outcome
+
+              def initialize(description:, domain:, certainty_level:, tolerance_at_time:)
+                @id                      = SecureRandom.uuid
+                @description             = description
+                @domain                  = domain
+                @certainty_level         = certainty_level.clamp(0.0, 1.0)
+                @tolerance_at_time       = tolerance_at_time
+                @actual_outcome          = nil
+                @acted_despite_uncertainty = certainty_level < tolerance_at_time
+                @created_at = Time.now.utc
+              end
+
+              def resolve!(outcome:)
+                @actual_outcome = outcome
+                self
+              end
+
+              def successful?
+                @actual_outcome == :success
+              end
+
+              def risky?
+                @certainty_level < 0.4
+              end
+
+              def decision_type
+                Constants::CERTAINTY_THRESHOLDS.each do |type, threshold|
+                  return type if @certainty_level >= threshold
+                end
+                :unknown
+              end
+
+              def to_h
+                {
+                  id:                        @id,
+                  description:               @description,
+                  domain:                    @domain,
+                  certainty_level:           @certainty_level,
+                  actual_outcome:            @actual_outcome,
+                  tolerance_at_time:         @tolerance_at_time,
+                  decision_type:             decision_type,
+                  acted_despite_uncertainty: @acted_despite_uncertainty,
+                  created_at:                @created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end