Class: Llmemory::Actions::Reason

Inherits:
Object
  • Object
show all
Defined in:
lib/llmemory/actions/reason.rb

Overview

CoALA's "reasoning" action: read working memory, call the LLM, write the result back to working memory. Unlike retrieval (long-term -> working) or learning (working -> long-term), reasoning reads from and writes to working memory, producing new information for the current decision.

It is a small, composable primitive — agents can chain reason -> retrieve -> reason — and deliberately does NOT touch long-term memory.

Llmemory::Actions::Reason.call(
working_memory: wm,
template: "Given goals {{goals}}, what is the next step?",
into: :intermediate_reasoning
)

template is either a String (with {slot} placeholders filled from working memory) or a callable that receives the WorkingMemory and returns the prompt. parse optionally transforms the raw LLM output before it is stored. into is the slot to write to (nil to reason without writing). Returns the parsed result.

Constant Summary collapse

DEFAULT_SLOT = 
:intermediate_reasoning

Class Method Summary collapse

Class Method Details

.call(working_memory:, template:, into: DEFAULT_SLOT, parse: nil, llm: nil) ⇒ Object 



27
28
29
30
31
32
33
34
 
# File 'lib/llmemory/actions/reason.rb', line 27

def self.call(working_memory:, template:, into: DEFAULT_SLOT, parse: nil, llm: nil)
  client = llm || Llmemory::LLM.client
  prompt = render(template, working_memory)
  output = client.invoke(prompt).to_s
  result = parse ? parse.call(output) : output
  working_memory.set(into, result) unless into.nil?
  result
end

.interpolate(text, slots) ⇒ Object 



41
42
43
44
45
46
 
# File 'lib/llmemory/actions/reason.rb', line 41

def self.interpolate(text, slots)
  text.gsub(/\{\{(\w+)\}\}/) do
    key = Regexp.last_match(1).to_sym
    slots.key?(key) ? slots[key].to_s : ""
  end
end

.render(template, working_memory) ⇒ Object 



36
37
38
39
 
# File 'lib/llmemory/actions/reason.rb', line 36

def self.render(template, working_memory)
  return template.call(working_memory).to_s if template.respond_to?(:call)
  interpolate(template.to_s, working_memory.to_h)
end