Class: Legion::Extensions::Agentic::Integration::DistributedCognition::Helpers::DistributionEngine

Inherits:
Object
  • Object
show all
Includes:
Constants
Defined in:
lib/legion/extensions/agentic/integration/distributed_cognition/helpers/distribution_engine.rb

Constant Summary

Constants included from Constants

Constants::CONTRIBUTION_TYPES, Constants::DECAY_RATE, Constants::DEFAULT_RELIABILITY, Constants::DISTRIBUTION_LABELS, Constants::MAX_ARTIFACTS, Constants::MAX_CONTRIBUTIONS, Constants::MAX_HISTORY, Constants::MAX_PARTICIPANTS, Constants::PARTICIPANT_TYPES, Constants::PENALTY_RATE, Constants::REINFORCEMENT_RATE, Constants::RELIABILITY_CEILING, Constants::RELIABILITY_FLOOR, Constants::RELIABILITY_LABELS, Constants::STALE_THRESHOLD

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ DistributionEngine

Returns a new instance of DistributionEngine.



14
15
16
17
18
 
# File 'lib/legion/extensions/agentic/integration/distributed_cognition/helpers/distribution_engine.rb', line 14

def initialize
  @participants = {}
  @contributions = []
  @history = []
end

Instance Attribute Details

#history ⇒ Object (readonly)

Returns the value of attribute history.



12
13
14
 
# File 'lib/legion/extensions/agentic/integration/distributed_cognition/helpers/distribution_engine.rb', line 12

def history
  @history
end

Instance Method Details

#by_domain(domain:) ⇒ Object 



57
58
59
 
# File 'lib/legion/extensions/agentic/integration/distributed_cognition/helpers/distribution_engine.rb', line 57

def by_domain(domain:)
  @participants.values.select { |p| p.domain == domain }
end

#by_type(participant_type:) ⇒ Object 



53
54
55
 
# File 'lib/legion/extensions/agentic/integration/distributed_cognition/helpers/distribution_engine.rb', line 53

def by_type(participant_type:)
  @participants.values.select { |p| p.participant_type == participant_type }
end

#cognitive_load_balance ⇒ Object 



79
80
81
82
83
 
# File 'lib/legion/extensions/agentic/integration/distributed_cognition/helpers/distribution_engine.rb', line 79

def cognitive_load_balance
  return {} if @participants.empty?

  @participants.transform_values(&:contribution_count)
end

#decay_all ⇒ Object 



85
86
87
 
# File 'lib/legion/extensions/agentic/integration/distributed_cognition/helpers/distribution_engine.rb', line 85

def decay_all
  @participants.each_value(&:decay!)
end

#distribution_label ⇒ Object 



74
75
76
77
 
# File 'lib/legion/extensions/agentic/integration/distributed_cognition/helpers/distribution_engine.rb', line 74

def distribution_label
  score = distribution_score
  DISTRIBUTION_LABELS.find { |range, _| range.cover?(score) }&.last || :unknown
end

#distribution_score ⇒ Object 



65
66
67
68
69
70
71
72
 
# File 'lib/legion/extensions/agentic/integration/distributed_cognition/helpers/distribution_engine.rb', line 65

def distribution_score
  return 0.0 if @contributions.empty? || @participants.size <= 1

  counts = @contributions.each_with_object(Hash.new(0)) do |contrib, hash|
    hash[contrib[:participant_id]] += 1
  end
  compute_evenness(counts.values)
end

#find_capable(capability:) ⇒ Object 



48
49
50
51
 
# File 'lib/legion/extensions/agentic/integration/distributed_cognition/helpers/distribution_engine.rb', line 48

def find_capable(capability:)
  @participants.values.select { |p| p.capable_of?(capability) }
                      .sort_by { |p| -p.reliability }
end

#most_reliable(limit: 5) ⇒ Object 



61
62
63
 
# File 'lib/legion/extensions/agentic/integration/distributed_cognition/helpers/distribution_engine.rb', line 61

def most_reliable(limit: 5)
  @participants.values.sort_by { |p| -p.reliability }.first(limit)
end

#prune_failing ⇒ Object 



89
90
91
92
93
 
# File 'lib/legion/extensions/agentic/integration/distributed_cognition/helpers/distribution_engine.rb', line 89

def prune_failing
  failing_ids = @participants.select { |_id, p| p.reliability <= 0.05 }.keys
  failing_ids.each { |id| @participants.delete(id) }
  failing_ids.size
end

#record_contribution(participant_id:, contribution_type:, success:, context: {}) ⇒ Object 



36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/legion/extensions/agentic/integration/distributed_cognition/helpers/distribution_engine.rb', line 36

def record_contribution(participant_id:, contribution_type:, success:, context: {})
  participant = @participants[participant_id]
  return { success: false, reason: :not_found } unless participant

  return { success: false, reason: :invalid_contribution_type } unless CONTRIBUTION_TYPES.include?(contribution_type)

  participant.contribute!(success: success)
  store_contribution(participant_id, contribution_type, success, context)
  record_history(:contributed, participant_id)
  build_contribution_result(participant, contribution_type)
end

#register_participant(name:, participant_type:, domain:, capabilities: []) ⇒ Object 



20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
# File 'lib/legion/extensions/agentic/integration/distributed_cognition/helpers/distribution_engine.rb', line 20

def register_participant(name:, participant_type:, domain:, capabilities: [])
  return { success: false, reason: :invalid_participant_type } unless PARTICIPANT_TYPES.include?(participant_type)

  evict_oldest if @participants.size >= MAX_PARTICIPANTS

  participant = Participant.new(
    name:             name,
    participant_type: participant_type,
    domain:           domain,
    capabilities:     capabilities
  )
  @participants[participant.id] = participant
  record_history(:registered, participant.id)
  participant
end

#to_h ⇒ Object 



95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/legion/extensions/agentic/integration/distributed_cognition/helpers/distribution_engine.rb', line 95

def to_h
  {
    total_participants:  @participants.size,
    agent_count:         by_type(participant_type: :agent).size,
    artifact_count:      by_type(participant_type: :artifact).size,
    environment_count:   by_type(participant_type: :environment).size,
    total_contributions: @contributions.size,
    distribution_score:  distribution_score,
    distribution_label:  distribution_label,
    history_count:       @history.size
  }
end