Module: Legion::Extensions::Agentic::Memory::Offloading::Runners::CognitiveOffloading

Includes:
Helpers::Lex
Included in:
Client
Defined in:
lib/legion/extensions/agentic/memory/offloading/runners/cognitive_offloading.rb

Instance Method Summary collapse

Instance Method Details

#items_by_type(item_type:, engine: nil) ⇒ Object 



69
70
71
72
73
74
 
# File 'lib/legion/extensions/agentic/memory/offloading/runners/cognitive_offloading.rb', line 69

def items_by_type(item_type:, engine: nil, **)
  eng = engine || offloading_engine
  items = eng.items_by_type(item_type: item_type)
  log.debug("[cognitive_offloading] items_by_type type=#{item_type} count=#{items.size}")
  { success: true, items: items.map(&:to_h), count: items.size }
end

#items_in_store(store_id:, engine: nil) ⇒ Object 



62
63
64
65
66
67
 
# File 'lib/legion/extensions/agentic/memory/offloading/runners/cognitive_offloading.rb', line 62

def items_in_store(store_id:, engine: nil, **)
  eng = engine || offloading_engine
  items = eng.items_in_store(store_id: store_id)
  log.debug("[cognitive_offloading] items_in_store store=#{store_id} count=#{items.size}")
  { success: true, items: items.map(&:to_h), count: items.size }
end

#most_important_offloaded(limit: 10, engine: nil) ⇒ Object 



76
77
78
79
80
81
 
# File 'lib/legion/extensions/agentic/memory/offloading/runners/cognitive_offloading.rb', line 76

def most_important_offloaded(limit: 10, engine: nil, **)
  eng = engine || offloading_engine
  items = eng.most_important_offloaded(limit: limit)
  log.debug("[cognitive_offloading] most_important limit=#{limit} count=#{items.size}")
  { success: true, items: items.map(&:to_h), count: items.size }
end

#offload_item(content:, item_type:, importance:, store_id:, engine: nil) ⇒ Object 



25
26
27
28
29
30
31
32
33
34
35
 
# File 'lib/legion/extensions/agentic/memory/offloading/runners/cognitive_offloading.rb', line 25

def offload_item(content:, item_type:, importance:, store_id:, engine: nil, **)
  eng = engine || offloading_engine
  item = eng.offload(content: content, item_type: item_type, importance: importance, store_id: store_id)
  if item
    log.info("[cognitive_offloading] offloaded item=#{item.id} type=#{item_type} importance=#{importance.round(2)} store=#{store_id}")
    { success: true, item: item.to_h }
  else
    log.warn("[cognitive_offloading] offload failed: limit reached or store not found store_id=#{store_id}")
    { success: false, reason: :offload_failed }
  end
end

#offloading_status(engine: nil) ⇒ Object 



83
84
85
86
87
88
89
 
# File 'lib/legion/extensions/agentic/memory/offloading/runners/cognitive_offloading.rb', line 83

def offloading_status(engine: nil, **)
  eng = engine || offloading_engine
  report = eng.offloading_report
  ratio = report[:offloading_ratio]
  log.debug("[cognitive_offloading] status items=#{report[:total_items]} stores=#{report[:total_stores]} ratio=#{ratio}")
  { success: true, report: report }
end

#register_store(name:, store_type:, engine: nil) ⇒ Object 



13
14
15
16
17
18
19
20
21
22
23
 
# File 'lib/legion/extensions/agentic/memory/offloading/runners/cognitive_offloading.rb', line 13

def register_store(name:, store_type:, engine: nil, **)
  eng = engine || offloading_engine
  store = eng.register_store(name: name, store_type: store_type)
  if store
    log.info("[cognitive_offloading] registered store name=#{name} type=#{store_type} id=#{store.id}")
    { success: true, store: store.to_h }
  else
    log.warn('[cognitive_offloading] register_store failed: limit reached or invalid store_type')
    { success: false, reason: :limit_reached }
  end
end

#report_retrieval_failure(item_id:, engine: nil) ⇒ Object 



49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/legion/extensions/agentic/memory/offloading/runners/cognitive_offloading.rb', line 49

def report_retrieval_failure(item_id:, engine: nil, **)
  eng = engine || offloading_engine
  item = eng.retrieve_failed(item_id: item_id)
  if item
    store = eng.stores[item.store_id]
    trust = store&.trust&.round(2)
    log.warn("[cognitive_offloading] retrieval failure item=#{item_id} store_trust=#{trust}")
    { success: true, item_id: item_id, store_trust: trust }
  else
    { success: false, reason: :not_found }
  end
end

#retrieve_item(item_id:, engine: nil) ⇒ Object 



37
38
39
40
41
42
43
44
45
46
47
 
# File 'lib/legion/extensions/agentic/memory/offloading/runners/cognitive_offloading.rb', line 37

def retrieve_item(item_id:, engine: nil, **)
  eng = engine || offloading_engine
  item = eng.retrieve(item_id: item_id)
  if item
    log.debug("[cognitive_offloading] retrieved item=#{item_id} count=#{item.retrieved_count}")
    { success: true, item: item.to_h }
  else
    log.warn("[cognitive_offloading] retrieve failed: item not found item_id=#{item_id}")
    { success: false, reason: :not_found }
  end
end