Something went wrong. Try again.
small gleam coding and (not yet) persistent agent daemon with a detachable cli forked from okami.mom/albedo
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292"""persistent-agent writes the agent's own dated memories in the background,through the request its turn just sent, and folds them in as the agent's ownturns; coding-lcm keeps its notes after its stored summaries; the former`lcm` name is migrated to `coding-lcm`."""
import jsonimport sqlite3import timeimport unittest
from harness import Albedo, Provider, exclusive, text
FORM = "It is time to form a new memory"FROM_ROWS = "You are remembering a stretch of your own life"MERGE = "Consolidate them into one memory"LEAF = "for another coding agent"NOTES = "keeping notes for yourself"LONG = "lorem ipsum dolor sit amet " * 200SETTINGS = { "foldTokens": 10000, "tailTokens": 3000, "memoryTokens": 9000, "chunkTokens": 1000,}
def last_user(request): for item in reversed(request["input"]): if item.get("role") == "user": content = item.get("content") return content if isinstance(content, str) else json.dumps(content) return ""
def contents(request): return [ (item.get("role"), json.dumps(item.get("content", ""))) for item in request["input"] ]
class Scenario(unittest.TestCase): """A session on one daemon, with the fake provider's script and helpers."""
def start(self, settings=None, memory=""): self.formed = 0 self.memory = memory
def reply(request): instructions = request.get("instructions", "") if FORM in last_user(request): self.formed += 1 return text(f"MEMORY-{self.formed}: what i lived{self.memory}") if MERGE in instructions: return text("CONSOLIDATED: the whole stretch") if FROM_ROWS in instructions: return text("REMEMBERED-NOW: from the rows") if LEAF in instructions: return text("SPEC: the user asked for things") if NOTES in instructions: return text("NOTES-TEXT") return text("answer")
self.provider = Provider(reply) self.addCleanup(self.provider.close)
def prepare(app): if settings is not None: app.write_extensions({"persistent-agent": settings})
self.app = Albedo(self.provider, protocol="responses", prepare=prepare) self.app.__enter__() self.addCleanup(self.app.__exit__, None, None, None) self.session = self.app.session()
def select(self, name): route = f"/sessions/{self.session}?view=configuration" with self.app.api(route) as response: json.load(response) etag = response.headers["ETag"] self.app.api( route, {"selection": {"extensions": {name: True}}}, method="PATCH", headers={"If-Match": etag}, ).close()
def turn(self, prompt): self.app.prompt(self.session, prompt).close() self.app.idle(self.session, timeout=60)
def compact(self, strategy=None): body = {} if strategy is None else {"strategy": strategy} with self.app.api(f"/sessions/{self.session}/compaction", body) as response: result = json.load(response) self.app.idle(self.session) return result
def requests(self): return [entry["request"] for entry in self.provider.requests]
def formations(self): return [r for r in self.requests() if FORM in last_user(r)]
def await_formations(self, count): deadline = time.monotonic() + 30 while len(self.formations()) < count: self.assertLess(time.monotonic(), deadline, "no memory formed") time.sleep(0.1) self.app.idle(self.session)
def rows(self, sql, *args): db = sqlite3.connect(self.app.home / "albedo.sqlite", timeout=10) try: return db.execute(sql, args).fetchall() finally: db.close()
# exclusive: the fixture writes persistent-agent's settings into extensions.json@exclusiveclass PersistentAgentTests(Scenario): def test_a_memory_forms_through_the_turns_own_request(self): self.start(SETTINGS) self.select("persistent-agent") self.turn("first " + LONG) self.await_formations(1) formation = self.formations()[0] turn = next( r for r in reversed(self.requests()) if FORM not in last_user(r) and r["input"] == formation["input"][:-1] ) self.assertEqual(turn["tools"], formation["tools"]) self.assertEqual(turn["instructions"], formation["instructions"]) self.assertIn("the message at", last_user(formation)) self.assertIn("first lorem ipsum", last_user(formation)) pending = self.rows( "SELECT summary FROM lcm_pending_memory WHERE session=?", self.session ) self.assertEqual(pending, [("MEMORY-1: what i lived",)])
def test_the_former_survives_a_kernel_restart_and_stops_when_disabled(self): # The former is a BEAM process, so no pid records it; a formed # memory is the observable effect. A kernel restart drops the # kernel and keeps the composition, so forming must continue. # Disabling the extension retires the composition, so no new # memory forms from later turns. self.start(SETTINGS) self.select("persistent-agent") self.turn("first " + LONG) self.await_formations(1)
with self.app.api(f"/sessions/{self.session}/kernel/restart", {}) as response: json.load(response) self.turn("second " + LONG) self.await_formations(2)
route = f"/sessions/{self.session}?view=configuration" with self.app.api(route) as response: json.load(response) etag = response.headers["ETag"] self.app.api( route, {"selection": {"extensions": {"persistent-agent": False}}}, method="PATCH", headers={"If-Match": etag}, ).close() with self.app.api( f"/sessions/{self.session}/reload", {"target": "session"} ) as response: self.assertEqual(json.load(response)["session"]["state"], "applied") self.turn("third " + LONG) deadline = time.monotonic() + 10 while time.monotonic() < deadline: self.assertEqual( len(self.formations()), 2, "a memory formed after persistent-agent was disabled", ) time.sleep(0.1)
def test_a_fold_shows_memories_as_the_agents_own_turns_without_notes(self): self.start(SETTINGS) self.select("persistent-agent") for n in range(3): self.turn(f"prompt {n} " + LONG) self.await_formations(3) self.assertEqual(self.compact()["state"], "compacted") self.turn("after the fold") sent = contents(self.requests()[-1]) first_memory = next( index for index, (role, content) in enumerate(sent) if role == "assistant" and "MEMORY-1" in content ) role, question = sent[first_memory - 1] self.assertEqual(role, "user") self.assertIn("What do you remember from then?", question) self.assertIn("UTC", question) self.assertNotIn("compaction notes", json.dumps(sent)) self.assertIn("after the fold", json.dumps(sent)) voices = { voice for (voice,) in self.rows( "SELECT voice FROM lcm_compaction_node WHERE session=?", self.session ) } self.assertEqual(voices, {"memory"})
def test_memories_past_their_budget_are_consolidated(self): self.start(SETTINGS, memory=" " + LONG) self.select("persistent-agent") for n in range(4): self.turn(f"prompt {n} " + LONG) self.await_formations(3) self.app.write_extensions( {"persistent-agent": {**SETTINGS, "memoryTokens": 2500}} ) self.assertEqual(self.compact()["state"], "compacted") self.assertTrue( any(MERGE in r.get("instructions", "") for r in self.requests()) ) self.turn("after consolidating") sent = json.dumps(contents(self.requests()[-1])) self.assertIn("Consolidated memory #", sent) self.assertIn("CONSOLIDATED: the whole stretch", sent)
def test_switching_from_coding_lcm_re_forms_recent_leaves_in_its_voice(self): self.start(SETTINGS) for n in range(3): self.turn(f"prompt {n} " + LONG) self.assertEqual(self.compact("coding-lcm")["state"], "compacted") self.assertEqual( self.rows( "SELECT voice FROM lcm_compaction_node WHERE session=?", self.session ), [("spec",)], ) self.assertEqual(self.compact("persistent-agent")["state"], "compacted") nodes = self.rows( "SELECT voice,summary FROM lcm_compaction_node WHERE session=? AND depth=0 ORDER BY first_seq", self.session, ) self.assertEqual(nodes[0], ("memory", "REMEMBERED-NOW: from the rows"))
class CodingLcmTests(Scenario): def test_notes_follow_the_stored_summaries(self): self.start() for n in range(3): self.turn(f"prompt {n} " + LONG) self.assertEqual(self.compact("coding-lcm")["state"], "compacted") self.turn("after the fold") sent = [content for _, content in contents(self.requests()[-1])] node = next(i for i, c in enumerate(sent) if "LCM summary node #" in c) notes = next(i for i, c in enumerate(sent) if "compaction notes" in c) self.assertLess(node, notes)
# exclusive: the test writes global defaults and restarts its daemon@exclusiveclass RenameTests(Scenario): def test_the_former_lcm_name_is_migrated(self): self.start() settings = json.loads((self.app.home / "extensions.json").read_text()) settings.setdefault("enabled", {})["lcm"] = False settings["lcm"] = {"tailPercent": 30} (self.app.home / "extensions.json").write_text(json.dumps(settings)) db = sqlite3.connect(self.app.home / "albedo.sqlite", timeout=10) try: db.execute( "INSERT INTO session_extensions(session,name,enabled) VALUES(?,?,1)", (self.session, "lcm"), ) db.commit() finally: db.close() self.app.restart() migrated = json.loads((self.app.home / "extensions.json").read_text()) self.assertNotIn("lcm", migrated) self.assertEqual(migrated["coding-lcm"], {"tailPercent": 30}) self.assertEqual(migrated["enabled"].get("coding-lcm"), False) self.assertNotIn("lcm", migrated["enabled"]) self.assertEqual( self.rows( "SELECT name FROM session_extensions WHERE session=? AND name LIKE '%lcm'", self.session, ), [("coding-lcm",)], )