111 lines
4.2 KiB
JavaScript
111 lines
4.2 KiB
JavaScript
/**
|
|
* iai-mcp memory-injection plugin for OpenCode (approach A).
|
|
*
|
|
* Pulls session-start memory from the iai-mcp daemon's localhost HTTP adapter
|
|
* and injects it directly into the model's system prompt via the
|
|
* `experimental.chat.system.transform` hook. The memory CONTENT is placed in
|
|
* context — no tool call, no injected "INIT" user turn, so the session title
|
|
* is generated from the user's real first message (clean).
|
|
*
|
|
* REPLACES iai-mcp-session-init.js — do NOT run both. session-init forces a
|
|
* tool call via a phantom turn (hijacks the title); this plugin needs neither.
|
|
*
|
|
* Requires the daemon's HTTP listener:
|
|
* - set IAI_DAEMON_HTTP_PORT in the daemon's systemd unit (e.g. "0" for an
|
|
* OS-assigned port) and restart it. The daemon writes the live port to
|
|
* ~/.iai-mcp/.http.port, which this plugin reads.
|
|
*
|
|
* wake_depth=standard is requested so l0/l1/l2/rich_club carry real content
|
|
* (minimal mode returns only opaque handles — nothing worth injecting).
|
|
* Override via IAI_MCP_WAKE_DEPTH (minimal|standard|deep).
|
|
*
|
|
* Fail-safe: any error is swallowed; system-prompt assembly must never break.
|
|
*/
|
|
|
|
const HOME = process.env.HOME || process.cwd();
|
|
const PORT_FILE = `${HOME}/.iai-mcp/.http.port`;
|
|
const WAKE_DEPTH = process.env.IAI_MCP_WAKE_DEPTH || "standard";
|
|
const FETCH_TIMEOUT_MS = 10000; // a cold runtime-graph build can exceed 5s
|
|
const MAX_ATTEMPTS = 3; // give up after this many failed fetches per session
|
|
|
|
const memo = new Map(); // sessionID -> injected text (cached on success)
|
|
const attempts = new Map(); // sessionID -> failed-fetch count
|
|
const inflight = new Set(); // sessionIDs with a fetch in flight (dedupe warm+inject)
|
|
|
|
async function readPort() {
|
|
const fs = await import("node:fs");
|
|
try {
|
|
const port = parseInt(fs.readFileSync(PORT_FILE, "utf8").trim(), 10);
|
|
return Number.isInteger(port) && port > 0 ? port : null;
|
|
} catch {
|
|
return null; // daemon HTTP not enabled / not up yet
|
|
}
|
|
}
|
|
|
|
async function fetchMemory(sessionId) {
|
|
const port = await readPort();
|
|
if (!port) return "";
|
|
const url =
|
|
`http://127.0.0.1:${port}/memory/session-context` +
|
|
`?session_id=${encodeURIComponent(sessionId)}` +
|
|
`&wake_depth=${encodeURIComponent(WAKE_DEPTH)}&format=text`;
|
|
try {
|
|
const res = await fetch(url, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
|
|
if (!res.ok) return "";
|
|
return (await res.text()).trim();
|
|
} catch {
|
|
return "";
|
|
}
|
|
}
|
|
|
|
// Centralised fetch+cache so the warm-on-create event and the per-turn
|
|
// transform hook share ONE in-flight fetch, one cache, and one attempt budget.
|
|
// This dedupes concurrent calls so a session never emits duplicate daemon-side
|
|
// session_started events.
|
|
async function ensureMemory(sessionId) {
|
|
const cached = memo.get(sessionId);
|
|
if (cached !== undefined) return cached;
|
|
if (inflight.has(sessionId)) return ""; // a fetch is already running
|
|
if ((attempts.get(sessionId) || 0) >= MAX_ATTEMPTS) return "";
|
|
inflight.add(sessionId);
|
|
try {
|
|
const text = await fetchMemory(sessionId);
|
|
if (text) memo.set(sessionId, text);
|
|
else attempts.set(sessionId, (attempts.get(sessionId) || 0) + 1);
|
|
return text;
|
|
} finally {
|
|
inflight.delete(sessionId);
|
|
}
|
|
}
|
|
|
|
export const IaiMcpMemoryInject = async () => {
|
|
return {
|
|
// Warm-on-create: prime the daemon graph cache (and our memo) as soon as a
|
|
// session appears — before the user's first turn — so the first transform
|
|
// injects immediately instead of paying the cold-build latency.
|
|
event: async ({ event }) => {
|
|
if (event.type !== "session.updated") return;
|
|
const sid = event.properties?.info?.id;
|
|
if (!sid) return;
|
|
try {
|
|
await ensureMemory(sid);
|
|
} catch {
|
|
// never throw from an event handler
|
|
}
|
|
},
|
|
|
|
"experimental.chat.system.transform": async (input, output) => {
|
|
try {
|
|
const sid = input?.sessionID;
|
|
if (!sid || !output || !Array.isArray(output.system)) return;
|
|
const text = await ensureMemory(sid);
|
|
if (text) {
|
|
output.system.push(`# iai-mcp memory (session start)\n${text}`);
|
|
}
|
|
} catch (err) {
|
|
// NEVER throw — a plugin error must not break system-prompt assembly.
|
|
console.error(`[iai-mcp] memory inject failed: ${err.message}`);
|
|
}
|
|
},
|
|
};
|
|
};
|