Solution for long term memory for agent coding CLIs and to facilitate handoff between different agent vendors
Rust
// Execute the generated adapter, rather than only checking template substrings.
// Run by `cargo test` (opencode2_plugin_passes_the_node_host_fixture), or by hand:
// AI_MEMORY_DATA_DIR=<empty dir> node --experimental-strip-types opencode2-plugin.mjs /absolute/plugin.ts
import assert from "node:assert/strict";
import { pathToFileURL } from "node:url";
import { readdirSync, readFileSync } from "node:fs";
import { join } from "node:path";
const requests = [];
globalThis.fetch = async (input, options = {}) => {
// Like a real fetch, a request cancelled before it is sent never arrives.
options.signal?.throwIfAborted();
const url = new URL(input);
requests.push({ url, payload: options.body ? JSON.parse(options.body) : undefined });
return new Response(url.pathname === "/handoff" ? "Remember the verified handoff." : "{}");
};
const { default: plugin } = await import(pathToFileURL(process.argv[2]).href);
function host(directory, records) {
const hooks = new Map();
const events = [];
let wake;
return {
hooks,
emit(event) {
events.push(event);
wake?.();
},
ctx: {
location: { directory },
session: {
async get({ sessionID }) {
const record = records.get(sessionID);
assert.ok(record, `unknown session ${sessionID}`);
return record;
},
async hook(name, callback) {
hooks.set(`session.${name}`, callback);
return { async dispose() {} };
},
},
tool: {
async hook(name, callback) {
hooks.set(`tool.${name}`, callback);
return { async dispose() {} };
},
},
event: {
async *subscribe({ signal }) {
signal.addEventListener("abort", () => wake?.(), { once: true });
while (!signal.aborted) {
if (!events.length) await new Promise((resolve) => { wake = resolve; });
while (events.length) yield events.shift();
}
},
},
},
};
}
async function until(predicate, message) {
const deadline = performance.now() + 5000;
while (!predicate()) {
assert.ok(performance.now() < deadline, message);
await new Promise((resolve) => setTimeout(resolve, 10));
}
}
const root = process.cwd();
const info = (id, parentID) => ({ id, title: id, location: { directory: root }, parentID });
const records = new Map([["root-a", info("root-a")], ["root-b", { ...info("root-b"), location: { directory: root + "/beta" } }],
["child", info("child", "root-a")]]);
const a = host(root, records);
const b = host(root + "/beta", records);
const disposeA = await plugin.setup(a.ctx);
const disposeB = await plugin.setup(b.ctx);
try {
// Existing/resumed sessions may never emit session.created after plugin load.
await a.hooks.get("session.prompt")({ sessionID: "root-a", messageID: "m1", prompt: { text: "remember alpha" } });
const first = { sessionID: "root-a", system: [] };
const next = { sessionID: "root-a", system: [] };
await a.hooks.get("session.context")(first);
await a.hooks.get("session.context")(next);
assert.deepEqual(first.system, next.system);
assert.equal(first.system.length, 1);
assert.equal(requests.filter((r) => r.url.pathname === "/handoff").length, 1, "claim once, inject repeatedly");
await a.hooks.get("session.prompt")({ sessionID: "child", messageID: "c1", prompt: { text: "child work" } });
const child = { sessionID: "child", system: [] };
await a.hooks.get("session.context")(child);
assert.equal(child.system.length, 0);
assert.equal(requests.filter((r) => r.url.pathname === "/handoff").length, 1, "child must not claim");
await a.hooks.get("tool.execute.after")({ sessionID: "root-a", tool: "example", id: "t1", input: {},
status: "completed", result: { content: "content-only tool evidence" } });
for (const type of ["session.execution.succeeded", "session.execution.failed", "session.execution.interrupted"]) {
a.emit({ type, data: { sessionID: "root-a" } });
b.emit({ type, data: { sessionID: "root-a" } });
}
a.emit({ type: "session.execution.succeeded", data: { sessionID: "child" } });
await until(() => requests.filter((r) => r.url.searchParams.get("event") === "stop").length === 4, "completion events delivered");
const stops = requests.filter((r) => r.url.searchParams.get("event") === "stop");
assert.equal(stops.filter((r) => r.payload.turn_checkpoint).length, 3);
assert.equal(stops.find((r) => r.payload.sessionID === "child").payload.agent_id, "root-a");
assert.ok(requests.some((r) => r.payload?.output === "content-only tool evidence"));
assert.ok(!requests.some((r) => r.url.searchParams.get("event") === "session-end"));
await b.hooks.get("session.prompt")({ sessionID: "root-b", messageID: "b1", prompt: { text: "beta" } });
await b.hooks.get("session.context")({ sessionID: "root-b", system: [] });
// Deletion, not unload, is the end signal: a deleted child keeps ancestry
// so its close does not hand the next session a sub-task baton.
a.emit({ type: "session.deleted", data: { sessionID: "child" } });
await until(() => requests.some((r) => r.url.searchParams.get("event") === "session-end" && r.payload.sessionID === "child"), "deleted session must end");
assert.equal(requests.find((r) => r.url.searchParams.get("event") === "session-end" && r.payload.sessionID === "child").payload.agent_id, "root-a", "child close must retain ancestry to suppress automatic handoffs");
// #1074: OpenCode unloads the plugin when it evicts idle location services;
// the host and its sessions stay alive, so unload must not end them.
await disposeA();
assert.ok(!requests.some((r) => r.url.searchParams.get("event") === "session-end" && r.payload.sessionID === "root-a"), "eviction unload must not end a live session");
assert.ok(!requests.some((r) => r.url.searchParams.get("event") === "session-end" && r.payload.sessionID === "root-b"), "location cleanup must not close another instance");
console.log("PASS: resumed sessions, retained handoff, child isolation, terminal events, deletion ends, unload does not");
} finally {
await disposeB();
}
const spool = join(process.env.AI_MEMORY_DATA_DIR, "hook-spool");
const realNow = Date.now;
globalThis.fetch = async () => { throw new Error("offline fixture"); };
Date.now = () => 1800000000000;
try {
const offlineA = host(root, records);
const offlineB = host(root + "/beta", records);
const closeA = await plugin.setup(offlineA.ctx);
const closeB = await plugin.setup(offlineB.ctx);
await Promise.all([
offlineA.hooks.get("session.prompt")({ sessionID: "root-a", messageID: "offline-a", prompt: { text: "offline alpha" } }),
offlineB.hooks.get("session.prompt")({ sessionID: "root-b", messageID: "offline-b", prompt: { text: "offline beta" } }),
]);
await Promise.all([closeA(), closeB()]);
const entries = readdirSync(spool).filter((name) => name.endsWith(".json")).map((name) => JSON.parse(readFileSync(join(spool, name), "utf8")));
for (const id of ["root-a", "root-b"]) {
assert.ok(entries.some((entry) => new URL(entry.url).searchParams.get("event") === "session-start" && JSON.parse(entry.body).sessionID === id), `same-millisecond spool must retain ${id}`);
}
assert.ok(entries.every((entry) => new URL(entry.url).searchParams.has("ingest_key")), "stable delivery keys survive spooling");
console.log("PASS: concurrent location spools do not overwrite same-millisecond events");
} finally {
Date.now = realNow;
}
// A server which accepts requests but never answers must not hold plugin unload
// behind every queued request's individual timeout.
globalThis.fetch = (_url, { signal } = {}) => new Promise((_resolve, reject) => {
if (signal.aborted) reject(signal.reason);
else signal.addEventListener("abort", () => reject(signal.reason), { once: true });
});
const stalled = host(root, records);
const closeStalled = await plugin.setup(stalled.ctx);
await stalled.hooks.get("session.prompt")({ sessionID: "root-a", messageID: "stalled", prompt: { text: "bounded shutdown" } });
for (let n = 0; n < 60; n++) {
await stalled.hooks.get("tool.execute.after")({ sessionID: "root-a", tool: "example", id: `pending-${n}`, input: {}, status: "completed", result: { content: "queued evidence" } });
}
stalled.emit({ type: "session.text.ended", data: { sessionID: "root-a", text: "last response" } });
stalled.emit({ type: "session.execution.succeeded", data: { sessionID: "root-a" } });
await new Promise((resolve) => setImmediate(resolve));
const shutdown = performance.now();
// The plugin's drain timers are unref'd; a real host process stays alive.
const host_alive = setInterval(() => {}, 1000);
await closeStalled();
clearInterval(host_alive);
assert.ok(performance.now() - shutdown < 5000, "unload must not wait for the entire network timeout backlog");
console.log("PASS: unload cancels stalled capture and remains bounded");