Module: Legion::Extensions::Agentic::Integration::DistributedCognition::Runners::DistributedCognition

Includes:
Helpers::Lex
Included in:
Client
Defined in:
lib/legion/extensions/agentic/integration/distributed_cognition/runners/distributed_cognition.rb

Instance Method Summary collapse

Instance Method Details

#distributed_cognition_stats ⇒ Object 



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

def distributed_cognition_stats(**)
  stats = engine.to_h
  log.debug('[distributed_cognition] stats ' \
            "participants=#{stats[:total_participants]}")
  { success: true }.merge(stats)
end

#distribution_assessment ⇒ Object 



56
57
58
59
60
61
62
63
64
 
# File 'lib/legion/extensions/agentic/integration/distributed_cognition/runners/distributed_cognition.rb', line 56

def distribution_assessment(**)
  score = engine.distribution_score
  label = engine.distribution_label
  balance = engine.cognitive_load_balance
  log.debug('[distributed_cognition] distribution ' \
            "score=#{score.round(3)} label=#{label}")
  { success: true, distribution_score: score, distribution_label: label,
    load_balance: balance }
end

#find_capable_participants(capability:) ⇒ Object 



42
43
44
45
46
47
48
 
# File 'lib/legion/extensions/agentic/integration/distributed_cognition/runners/distributed_cognition.rb', line 42

def find_capable_participants(capability:, **)
  participants = engine.find_capable(capability: capability)
  log.debug('[distributed_cognition] find_capable ' \
            "#{capability} count=#{participants.size}")
  { success: true, capability: capability,
    participants: participants.map(&:to_h), count: participants.size }
end

#most_reliable_participants(limit: 5) ⇒ Object 



50
51
52
53
54
 
# File 'lib/legion/extensions/agentic/integration/distributed_cognition/runners/distributed_cognition.rb', line 50

def most_reliable_participants(limit: 5, **)
  participants = engine.most_reliable(limit: limit)
  log.debug("[distributed_cognition] most_reliable count=#{participants.size}")
  { success: true, participants: participants.map(&:to_h), count: participants.size }
end

#participants_by_domain(domain:) ⇒ Object 



74
75
76
77
78
79
80
 
# File 'lib/legion/extensions/agentic/integration/distributed_cognition/runners/distributed_cognition.rb', line 74

def participants_by_domain(domain:, **)
  participants = engine.by_domain(domain: domain)
  log.debug("[distributed_cognition] by_domain=#{domain} " \
            "count=#{participants.size}")
  { success: true, domain: domain,
    participants: participants.map(&:to_h), count: participants.size }
end

#participants_by_type(participant_type:) ⇒ Object 



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

def participants_by_type(participant_type:, **)
  participants = engine.by_type(participant_type: participant_type)
  log.debug("[distributed_cognition] by_type=#{participant_type} " \
            "count=#{participants.size}")
  { success: true, participant_type: participant_type,
    participants: participants.map(&:to_h), count: participants.size }
end

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



32
33
34
35
36
37
38
39
40
 
# File 'lib/legion/extensions/agentic/integration/distributed_cognition/runners/distributed_cognition.rb', line 32

def record_cognitive_contribution(participant_id:, contribution_type:, success:, context: {}, **)
  result = engine.record_contribution(
    participant_id: participant_id, contribution_type: contribution_type,
    success: success, context: context
  )
  log.debug('[distributed_cognition] contribution ' \
            "type=#{contribution_type} success=#{success}")
  result
end

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



13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/legion/extensions/agentic/integration/distributed_cognition/runners/distributed_cognition.rb', line 13

def register_cognitive_participant(name:, participant_type:, domain:, capabilities: [], **)
  unless Helpers::Constants::PARTICIPANT_TYPES.include?(participant_type)
    return { success: false, error: :invalid_participant_type,
             valid_types: Helpers::Constants::PARTICIPANT_TYPES }
  end

  result = engine.register_participant(
    name: name, participant_type: participant_type,
    domain: domain, capabilities: capabilities
  )

  return result unless result.is_a?(Helpers::Participant)

  log.debug("[distributed_cognition] registered #{name} " \
            "type=#{participant_type} id=#{result.id[0..7]}")
  { success: true, participant_id: result.id, name: name,
    participant_type: participant_type, domain: domain }
end

#update_distributed_cognition ⇒ Object 



82
83
84
85
86
87
 
# File 'lib/legion/extensions/agentic/integration/distributed_cognition/runners/distributed_cognition.rb', line 82

def update_distributed_cognition(**)
  engine.decay_all
  pruned = engine.prune_failing
  log.debug("[distributed_cognition] decay+prune pruned=#{pruned}")
  { success: true, pruned: pruned }
end