lex-agentic-social 0.1.0

data/lib/legion/extensions/agentic/social/theory_of_mind/client.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/social/theory_of_mind/helpers/constants'
+require 'legion/extensions/agentic/social/theory_of_mind/helpers/agent_model'
+require 'legion/extensions/agentic/social/theory_of_mind/helpers/mental_state_tracker'
+require 'legion/extensions/agentic/social/theory_of_mind/runners/theory_of_mind'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module TheoryOfMind
+          class Client
+            include Runners::TheoryOfMind
+
+            attr_reader :tracker
+
+            def initialize(tracker: nil, **)
+              @tracker = tracker || Helpers::MentalStateTracker.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/theory_of_mind/helpers/agent_model.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module TheoryOfMind
+          module Helpers
+            class AgentModel
+              attr_reader :agent_id, :beliefs, :desires, :intentions,
+                          :prediction_accuracy, :interaction_count, :created_at, :updated_at
+
+              def initialize(agent_id)
+                @agent_id            = agent_id
+                @beliefs             = {}
+                @desires             = []
+                @intentions          = []
+                @prediction_accuracy = 0.5
+                @interaction_count   = 0
+                @created_at          = Time.now.utc
+                @updated_at          = Time.now.utc
+              end
+
+              def update_belief(domain:, content:, confidence:, source: :inference)
+                @beliefs[domain] = {
+                  content:    content,
+                  confidence: confidence.clamp(0.0, 1.0),
+                  source:     source,
+                  updated_at: Time.now.utc
+                }
+                trim_beliefs
+                touch
+              end
+
+              def update_desire(goal:, priority: :medium)
+                existing = @desires.find { |d| d[:goal] == goal }
+                if existing
+                  existing[:priority]    = priority
+                  existing[:observed_at] = Time.now.utc
+                else
+                  @desires << { goal: goal, priority: priority, observed_at: Time.now.utc }
+                  trim_desires
+                end
+                touch
+              end
+
+              def update_intention(action:, confidence: :possible)
+                existing = @intentions.find { |i| i[:action] == action }
+                if existing
+                  existing[:confidence]    = confidence
+                  existing[:estimated_at]  = Time.now.utc
+                else
+                  @intentions << { action: action, confidence: confidence, estimated_at: Time.now.utc }
+                  trim_intentions
+                end
+                touch
+              end
+
+              def belief_for(domain)
+                @beliefs[domain]
+              end
+
+              def strongest_desire
+                @desires.max_by { |d| Constants::DESIRE_PRIORITIES[d[:priority]] || 0 }
+              end
+
+              def most_likely_intention
+                @intentions.max_by { |i| Constants::INTENTION_CONFIDENCE_LEVELS[i[:confidence]] || 0 }
+              end
+
+              def false_beliefs(known_truths)
+                @beliefs.each_with_object({}) do |(domain, belief), result|
+                  truth = known_truths[domain]
+                  next unless truth
+                  next if truth == belief[:content]
+
+                  result[domain] = {
+                    agent_believes: belief[:content],
+                    actual_truth:   truth,
+                    confidence:     belief[:confidence]
+                  }
+                end
+              end
+
+              def update_prediction_accuracy(outcome)
+                score = case outcome
+                        when :correct           then 1.0
+                        when :partially_correct then 0.5
+                        when :incorrect         then 0.0
+                        else return
+                        end
+                alpha = Constants::PREDICTION_ALPHA
+                @prediction_accuracy = (@prediction_accuracy * (1.0 - alpha)) + (score * alpha)
+                @interaction_count += 1
+                touch
+              end
+
+              def decay_beliefs
+                @beliefs.each do |domain, belief|
+                  belief[:confidence] -= Constants::BELIEF_DECAY_RATE
+                  @beliefs.delete(domain) if belief[:confidence] < Constants::CONFIDENCE_THRESHOLD
+                end
+              end
+
+              def perspective
+                {
+                  knowledge:       @beliefs.transform_values { |b| b[:content] },
+                  goals:           @desires.map { |d| d[:goal] },
+                  emotional_state: infer_emotional_state,
+                  constraints:     infer_constraints,
+                  recent_actions:  @intentions.last(5).map { |i| i[:action] }
+                }
+              end
+
+              def to_h
+                {
+                  agent_id:            @agent_id,
+                  belief_count:        @beliefs.size,
+                  desire_count:        @desires.size,
+                  intention_count:     @intentions.size,
+                  prediction_accuracy: @prediction_accuracy.round(4),
+                  interaction_count:   @interaction_count,
+                  strongest_desire:    strongest_desire&.dig(:goal),
+                  likely_action:       most_likely_intention&.dig(:action)
+                }
+              end
+
+              private
+
+              def touch
+                @updated_at = Time.now.utc
+              end
+
+              def infer_emotional_state
+                return :unknown if @beliefs.empty? && @desires.empty?
+
+                conflict_count = @desires.count { |d| d[:priority] == :critical }
+                return :stressed if conflict_count > 1
+
+                :stable
+              end
+
+              def infer_constraints
+                low_confidence = @beliefs.count { |_, b| b[:confidence] < 0.5 }
+                { uncertain_domains: low_confidence, total_beliefs: @beliefs.size }
+              end
+
+              def trim_beliefs
+                return if @beliefs.size <= Constants::MAX_BELIEFS_PER_AGENT
+
+                sorted = @beliefs.sort_by { |_, b| b[:confidence] }
+                sorted.first(@beliefs.size - Constants::MAX_BELIEFS_PER_AGENT).each { |domain, _| @beliefs.delete(domain) } # rubocop:disable Style/HashEachMethods
+              end
+
+              def trim_desires
+                return if @desires.size <= Constants::MAX_DESIRES_PER_AGENT
+
+                @desires.sort_by! { |d| -(Constants::DESIRE_PRIORITIES[d[:priority]] || 0) }
+                @desires.slice!(Constants::MAX_DESIRES_PER_AGENT..)
+              end
+
+              def trim_intentions
+                return if @intentions.size <= Constants::MAX_INTENTIONS_PER_AGENT
+
+                @intentions.shift(@intentions.size - Constants::MAX_INTENTIONS_PER_AGENT)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/theory_of_mind/helpers/constants.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module TheoryOfMind
+          module Helpers
+            module Constants
+              MAX_AGENT_MODELS = 100
+
+              MAX_BELIEFS_PER_AGENT = 50
+
+              MAX_DESIRES_PER_AGENT = 20
+
+              MAX_INTENTIONS_PER_AGENT = 10
+
+              BELIEF_DECAY_RATE = 0.01
+
+              CONFIDENCE_THRESHOLD = 0.3
+
+              PREDICTION_ALPHA = 0.15
+
+              STALE_BELIEF_THRESHOLD = 3600
+
+              PERSPECTIVE_DIMENSIONS = %i[
+                knowledge
+                goals
+                emotional_state
+                constraints
+                recent_actions
+              ].freeze
+
+              BELIEF_SOURCES = %i[
+                direct_observation
+                communication
+                inference
+                reputation
+                behavioral_pattern
+              ].freeze
+
+              INTENTION_CONFIDENCE_LEVELS = {
+                certain:  0.9,
+                likely:   0.7,
+                possible: 0.5,
+                unlikely: 0.3,
+                unknown:  0.1
+              }.freeze
+
+              DESIRE_PRIORITIES = {
+                critical: 1.0,
+                high:     0.75,
+                medium:   0.5,
+                low:      0.25,
+                latent:   0.1
+              }.freeze
+
+              PREDICTION_OUTCOMES = %i[
+                correct
+                partially_correct
+                incorrect
+                unresolved
+              ].freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/theory_of_mind/helpers/mental_state_tracker.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module TheoryOfMind
+          module Helpers
+            class MentalStateTracker
+              attr_reader :agent_models, :prediction_log
+
+              def initialize
+                @agent_models = {}
+                @prediction_log = []
+              end
+
+              def model_for(agent_id)
+                @agent_models[agent_id] ||= AgentModel.new(agent_id)
+                trim_models
+                @agent_models[agent_id]
+              end
+
+              def update_belief(agent_id:, domain:, content:, confidence:, source: :inference)
+                model = model_for(agent_id)
+                model.update_belief(domain: domain, content: content, confidence: confidence, source: source)
+              end
+
+              def update_desire(agent_id:, goal:, priority: :medium)
+                model = model_for(agent_id)
+                model.update_desire(goal: goal, priority: priority)
+              end
+
+              def infer_intention(agent_id:, action:, confidence: :possible)
+                model = model_for(agent_id)
+                model.update_intention(action: action, confidence: confidence)
+              end
+
+              def predict_behavior(agent_id:, context: {})
+                model = @agent_models[agent_id]
+                return nil unless model
+
+                intention = model.most_likely_intention
+                desire    = model.strongest_desire
+
+                prediction = {
+                  agent_id:           agent_id,
+                  predicted_action:   intention&.dig(:action),
+                  action_confidence:  intention&.dig(:confidence),
+                  underlying_desire:  desire&.dig(:goal),
+                  context_considered: context.keys,
+                  model_accuracy:     model.prediction_accuracy.round(4),
+                  interactions_seen:  model.interaction_count
+                }
+
+                @prediction_log << prediction.merge(predicted_at: Time.now.utc)
+                trim_prediction_log
+
+                prediction
+              end
+
+              def record_prediction_outcome(agent_id:, outcome:)
+                model = @agent_models[agent_id]
+                return nil unless model
+
+                model.update_prediction_accuracy(outcome)
+              end
+
+              def false_belief_check(agent_id:, known_truths:)
+                model = @agent_models[agent_id]
+                return nil unless model
+
+                model.false_beliefs(known_truths)
+              end
+
+              def perspective_take(agent_id:)
+                model = @agent_models[agent_id]
+                return nil unless model
+
+                model.perspective
+              end
+
+              def compare_agents(agent_ids:)
+                models = agent_ids.filter_map { |id| @agent_models[id] }
+                return nil if models.empty?
+
+                {
+                  agents:            models.map(&:to_h),
+                  shared_beliefs:    find_shared_beliefs(models),
+                  conflicting_goals: find_conflicting_goals(models),
+                  interaction_gap:   interaction_gap(models)
+                }
+              end
+
+              def decay_all
+                @agent_models.each_value(&:decay_beliefs)
+                @agent_models.reject! { |_, m| m.beliefs.empty? && m.desires.empty? && m.intentions.empty? }
+              end
+
+              def agents_tracked
+                @agent_models.size
+              end
+
+              def total_beliefs
+                @agent_models.values.sum { |m| m.beliefs.size }
+              end
+
+              def avg_prediction_accuracy
+                return 0.0 if @agent_models.empty?
+
+                total = @agent_models.values.sum(&:prediction_accuracy)
+                (total / @agent_models.size).round(4)
+              end
+
+              def to_h
+                {
+                  agents_tracked:          agents_tracked,
+                  total_beliefs:           total_beliefs,
+                  avg_prediction_accuracy: avg_prediction_accuracy,
+                  prediction_log_size:     @prediction_log.size
+                }
+              end
+
+              private
+
+              def find_shared_beliefs(models)
+                return [] if models.size < 2
+
+                domains = models.map { |m| m.beliefs.keys }
+                shared  = domains.reduce(:&) || []
+                shared.map do |domain|
+                  values = models.map { |m| m.belief_for(domain)[:content] }
+                  { domain: domain, values: values, consensus: values.uniq.size == 1 }
+                end
+              end
+
+              def find_conflicting_goals(models)
+                return [] if models.size < 2
+
+                all_goals = models.flat_map { |m| m.desires.map { |d| { agent: m.agent_id, goal: d[:goal], priority: d[:priority] } } }
+                goal_groups = all_goals.group_by { |g| g[:goal] }
+                goal_groups.select { |_, entries| entries.size > 1 }.map do |goal, entries|
+                  { goal: goal, agents: entries.map { |e| e[:agent] } }
+                end
+              end
+
+              def interaction_gap(models)
+                counts = models.map(&:interaction_count)
+                return 0 if counts.empty?
+
+                counts.max - counts.min
+              end
+
+              def trim_models
+                return if @agent_models.size <= Constants::MAX_AGENT_MODELS
+
+                oldest = @agent_models.sort_by { |_, m| m.updated_at }
+                oldest.first(@agent_models.size - Constants::MAX_AGENT_MODELS).each { |id, _| @agent_models.delete(id) } # rubocop:disable Style/HashEachMethods
+              end
+
+              def trim_prediction_log
+                @prediction_log.shift while @prediction_log.size > 200
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/theory_of_mind/runners/theory_of_mind.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module TheoryOfMind
+          module Runners
+            module TheoryOfMind
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def update_theory_of_mind(tick_results: {}, **)
+                extract_social_observations(tick_results)
+                extract_mesh_observations(tick_results)
+                tracker.decay_all
+
+                Legion::Logging.debug "[tom] agents=#{tracker.agents_tracked} " \
+                                      "beliefs=#{tracker.total_beliefs} accuracy=#{tracker.avg_prediction_accuracy}"
+
+                tracker.to_h
+              end
+
+              def observe_agent(agent_id:, observations: {}, **)
+                apply_belief_observation(agent_id, observations)
+                apply_desire_observation(agent_id, observations)
+                apply_intention_observation(agent_id, observations)
+
+                Legion::Logging.debug "[tom] observed agent=#{agent_id}"
+                { success: true, model: tracker.model_for(agent_id).to_h }
+              end
+
+              def predict_behavior(agent_id:, context: {}, **)
+                prediction = tracker.predict_behavior(agent_id: agent_id, context: context)
+                return { error: 'unknown agent' } unless prediction
+
+                Legion::Logging.debug "[tom] predicted action for #{agent_id}: #{prediction[:predicted_action]}"
+                prediction
+              end
+
+              def record_outcome(agent_id:, outcome:, **)
+                result = tracker.record_prediction_outcome(agent_id: agent_id, outcome: outcome.to_sym)
+                return { error: 'unknown agent' } unless result
+
+                Legion::Logging.debug "[tom] outcome for #{agent_id}: #{outcome}"
+                { success: true, accuracy: tracker.model_for(agent_id).prediction_accuracy.round(4) }
+              end
+
+              def check_false_beliefs(agent_id:, known_truths:, **)
+                false_beliefs = tracker.false_belief_check(agent_id: agent_id, known_truths: known_truths)
+                return { error: 'unknown agent' } unless false_beliefs
+
+                Legion::Logging.debug "[tom] false beliefs for #{agent_id}: #{false_beliefs.size}"
+                { agent_id: agent_id, false_beliefs: false_beliefs, count: false_beliefs.size }
+              end
+
+              def perspective_take(agent_id:, **)
+                perspective = tracker.perspective_take(agent_id: agent_id)
+                return { error: 'unknown agent' } unless perspective
+
+                Legion::Logging.debug "[tom] perspective for #{agent_id}"
+                { agent_id: agent_id, perspective: perspective }
+              end
+
+              def compare_agents(agent_ids:, **)
+                comparison = tracker.compare_agents(agent_ids: agent_ids)
+                return { error: 'no matching agents' } unless comparison
+
+                Legion::Logging.debug "[tom] comparing #{agent_ids.size} agents"
+                comparison
+              end
+
+              def mental_state(agent_id:, **)
+                model = tracker.agent_models[agent_id]
+                return { error: 'unknown agent' } unless model
+
+                {
+                  agent_id:    agent_id,
+                  beliefs:     model.beliefs.transform_values { |b| { content: b[:content], confidence: b[:confidence].round(4) } },
+                  desires:     model.desires,
+                  intentions:  model.intentions,
+                  accuracy:    model.prediction_accuracy.round(4),
+                  perspective: model.perspective
+                }
+              end
+
+              def tom_stats(**)
+                Legion::Logging.debug '[tom] stats'
+                tracker.to_h.merge(
+                  models: tracker.agent_models.transform_values(&:to_h)
+                )
+              end
+
+              private
+
+              def tracker
+                @tracker ||= Helpers::MentalStateTracker.new
+              end
+
+              def apply_belief_observation(agent_id, obs)
+                return unless obs[:domain] && obs[:belief]
+
+                tracker.update_belief(
+                  agent_id:   agent_id,
+                  domain:     obs[:domain],
+                  content:    obs[:belief],
+                  confidence: obs[:confidence] || 0.5,
+                  source:     obs[:source] || :inference
+                )
+              end
+
+              def apply_desire_observation(agent_id, obs)
+                return unless obs[:goal]
+
+                tracker.update_desire(agent_id: agent_id, goal: obs[:goal], priority: obs[:goal_priority] || :medium)
+              end
+
+              def apply_intention_observation(agent_id, obs)
+                return unless obs[:action]
+
+                tracker.infer_intention(agent_id: agent_id, action: obs[:action], confidence: obs[:action_confidence] || :possible)
+              end
+
+              def extract_social_observations(tick_results)
+                social = tick_results.dig(:social, :reputation_updates)
+                return unless social.is_a?(Array)
+
+                social.each do |update|
+                  tracker.update_belief(
+                    agent_id:   update[:agent_id],
+                    domain:     :social_standing,
+                    content:    update[:standing],
+                    confidence: update[:composite] || 0.5,
+                    source:     :direct_observation
+                  )
+                end
+              end
+
+              def extract_mesh_observations(tick_results)
+                messages = tick_results.dig(:mesh_interface, :received_messages)
+                return unless messages.is_a?(Array)
+
+                messages.each do |msg|
+                  next unless msg[:from]
+
+                  tracker.infer_intention(
+                    agent_id:   msg[:from],
+                    action:     msg[:type] || :communicate,
+                    confidence: :likely
+                  )
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/theory_of_mind/version.rb

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

data/lib/legion/extensions/agentic/social/theory_of_mind.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/social/theory_of_mind/version'
+require 'legion/extensions/agentic/social/theory_of_mind/helpers/constants'
+require 'legion/extensions/agentic/social/theory_of_mind/helpers/agent_model'
+require 'legion/extensions/agentic/social/theory_of_mind/helpers/mental_state_tracker'
+require 'legion/extensions/agentic/social/theory_of_mind/runners/theory_of_mind'
+require 'legion/extensions/agentic/social/theory_of_mind/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module TheoryOfMind
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/trust/actors/decay.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/every'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Trust
+          module Actor
+            class Decay < Legion::Extensions::Actors::Every
+              def runner_class
+                Legion::Extensions::Agentic::Social::Trust::Runners::Trust
+              end
+
+              def runner_function
+                'decay_trust'
+              end
+
+              def time
+                300
+              end
+
+              def run_now?
+                false
+              end
+
+              def use_runner?
+                false
+              end
+
+              def check_subtask?
+                false
+              end
+
+              def generate_task?
+                false
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end