@agentmemory/agentmemory 0.8.12 → 0.9.0

package/dist/standalone.mjs

@@ -1110,7 +1110,7 @@ function getStandalonePersistPath() {
 
 //#endregion
 //#region src/version.ts
-const VERSION = "0.8.12";
+const VERSION = "0.9.0";
 
 //#endregion
 //#region src/state/schema.ts
@@ -1118,6 +1118,81 @@ function generateId(prefix) {
 	return `${prefix}_${Date.now().toString(36)}_${crypto.randomUUID().replace(/-/g, "").slice(0, 12)}`;
 }
 
+//#endregion
+//#region src/mcp/rest-proxy.ts
+const DEFAULT_URL = "http://localhost:3111";
+const HEALTH_PROBE_TIMEOUT_MS = 500;
+const CALL_TIMEOUT_MS = 15e3;
+const LOCAL_MODE_TTL_MS = 3e4;
+let cached = null;
+let cachedAt = 0;
+let probeInFlight = null;
+function baseUrl() {
+	return (process.env["AGENTMEMORY_URL"] || DEFAULT_URL).replace(/\/+$/, "");
+}
+function authHeader() {
+	const secret = process.env["AGENTMEMORY_SECRET"];
+	return secret ? { authorization: `Bearer ${secret}` } : {};
+}
+async function probe(url) {
+	try {
+		return (await fetch(`${url}/agentmemory/livez`, {
+			method: "GET",
+			headers: authHeader(),
+			signal: AbortSignal.timeout(HEALTH_PROBE_TIMEOUT_MS)
+		})).ok;
+	} catch {
+		return false;
+	}
+}
+function invalidateHandle() {
+	cached = null;
+	cachedAt = 0;
+}
+async function resolveHandle() {
+	const now = Date.now();
+	if (cached) if (cached.mode === "local" && now - cachedAt >= LOCAL_MODE_TTL_MS) {
+		cached = null;
+		cachedAt = 0;
+	} else return cached;
+	if (probeInFlight) return probeInFlight;
+	const url = baseUrl();
+	probeInFlight = (async () => {
+		if (await probe(url)) {
+			const handle = {
+				mode: "proxy",
+				baseUrl: url,
+				call: async (path, init) => {
+					const res = await fetch(`${url}${path}`, {
+						...init,
+						headers: {
+							"content-type": "application/json",
+							...authHeader(),
+							...init?.headers
+						},
+						signal: AbortSignal.timeout(CALL_TIMEOUT_MS)
+					});
+					if (!res.ok) throw new Error(`${init?.method || "GET"} ${path} -> ${res.status} ${res.statusText}`);
+					const text = await res.text();
+					return text ? JSON.parse(text) : null;
+				}
+			};
+			cached = handle;
+			cachedAt = Date.now();
+			return handle;
+		}
+		const local = { mode: "local" };
+		cached = local;
+		cachedAt = Date.now();
+		return local;
+	})();
+	try {
+		return await probeInFlight;
+	} finally {
+		probeInFlight = null;
+	}
+}
+
 //#endregion
 //#region src/mcp/standalone.ts
 const IMPLEMENTED_TOOLS = new Set([
@@ -1135,6 +1210,13 @@ const SERVER_INFO = {
 	protocolVersion: "2024-11-05"
 };
 const kv = new InMemoryKV(getStandalonePersistPath());
+let modeAnnounced = false;
+function announceMode(handle) {
+	if (modeAnnounced) return;
+	modeAnnounced = true;
+	if (handle.mode === "proxy") process.stderr.write(`[@agentmemory/mcp] proxying to agentmemory server at ${handle.baseUrl}\n`);
+	else process.stderr.write(`[@agentmemory/mcp] no server reachable at ${process.env["AGENTMEMORY_URL"] || "http://localhost:3111"}; falling back to local InMemoryKV\n`);
+}
 function normalizeList(value) {
 	if (!value) return [];
 	if (Array.isArray(value)) return value.map((v) => typeof v === "string" ? v.trim() : "").filter((v) => v.length > 0);
@@ -1149,21 +1231,94 @@ function parseLimit(raw, fallback = DEFAULT_LIMIT) {
 	if (!Number.isFinite(n) || n <= 0) return fallback;
 	return Math.min(Math.floor(n), MAX_LIMIT);
 }
-async function handleToolCall(toolName, args, kvInstance = kv) {
+function textResponse(payload, pretty = false) {
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(payload, null, pretty ? 2 : 0)
+	}] };
+}
+function validate(toolName, args) {
+	if (!IMPLEMENTED_TOOLS.has(toolName)) throw new Error(`Unknown tool: ${toolName}`);
+	const v = { tool: toolName };
 	switch (toolName) {
 		case "memory_save": {
-			const rawContent = args.content;
-			if (typeof rawContent !== "string" || !rawContent.trim()) throw new Error("content is required");
-			const content = rawContent;
+			const content = args["content"];
+			if (typeof content !== "string" || !content.trim()) throw new Error("content is required");
+			v.content = content;
+			v.type = args["type"] || "fact";
+			v.concepts = normalizeList(args["concepts"]);
+			v.files = normalizeList(args["files"]);
+			return v;
+		}
+		case "memory_recall":
+		case "memory_smart_search": {
+			const query = args["query"];
+			if (typeof query !== "string" || !query.trim()) throw new Error("query is required");
+			v.query = query.trim();
+			v.limit = parseLimit(args["limit"]);
+			return v;
+		}
+		case "memory_sessions":
+			v.limit = parseLimit(args["limit"], 20);
+			return v;
+		case "memory_governance_delete": {
+			const ids = normalizeList(args["memoryIds"]);
+			if (ids.length === 0) throw new Error("memoryIds is required");
+			v.memoryIds = ids;
+			v.reason = args["reason"] || "plugin skill request";
+			return v;
+		}
+		case "memory_export": return v;
+		case "memory_audit":
+			v.limit = parseLimit(args["limit"], 50);
+			return v;
+		default: throw new Error(`Unknown tool: ${toolName}`);
+	}
+}
+async function handleProxy(v, handle) {
+	switch (v.tool) {
+		case "memory_save": return textResponse(await handle.call("/agentmemory/remember", {
+			method: "POST",
+			body: JSON.stringify({
+				content: v.content,
+				type: v.type,
+				concepts: v.concepts,
+				files: v.files
+			})
+		}));
+		case "memory_recall":
+		case "memory_smart_search": return textResponse(await handle.call("/agentmemory/smart-search", {
+			method: "POST",
+			body: JSON.stringify({
+				query: v.query,
+				limit: v.limit
+			})
+		}), true);
+		case "memory_sessions": return textResponse(await handle.call(`/agentmemory/sessions?limit=${v.limit}`, { method: "GET" }), true);
+		case "memory_governance_delete": return textResponse(await handle.call("/agentmemory/governance/memories", {
+			method: "POST",
+			body: JSON.stringify({
+				memoryIds: v.memoryIds,
+				reason: v.reason
+			})
+		}));
+		case "memory_export": return textResponse(await handle.call("/agentmemory/export", { method: "GET" }), true);
+		case "memory_audit": return textResponse(await handle.call(`/agentmemory/audit?limit=${v.limit}`, { method: "GET" }), true);
+		default: throw new Error(`Unknown tool: ${v.tool}`);
+	}
+}
+async function handleLocal(v, kvInstance) {
+	switch (v.tool) {
+		case "memory_save": {
 			const id = generateId("mem");
 			const isoNow = (/* @__PURE__ */ new Date()).toISOString();
 			await kvInstance.set("mem:memories", id, {
 				id,
-				type: args.type || "fact",
-				title: content.slice(0, 80),
-				content,
-				concepts: normalizeList(args.concepts),
-				files: normalizeList(args.files),
+				type: v.type,
+				title: (v.content || "").slice(0, 80),
+				content: v.content,
+				concepts: v.concepts,
+				files: v.files,
 				createdAt: isoNow,
 				updatedAt: isoNow,
 				strength: 7,
@@ -1172,81 +1327,69 @@ async function handleToolCall(toolName, args, kvInstance = kv) {
 				sessionIds: []
 			});
 			kvInstance.persist();
-			return { content: [{
-				type: "text",
-				text: JSON.stringify({ saved: id })
-			}] };
+			return textResponse({ saved: id });
 		}
 		case "memory_recall":
 		case "memory_smart_search": {
-			const rawQuery = args.query;
-			if (typeof rawQuery !== "string" || !rawQuery.trim()) throw new Error("query is required");
-			const query = rawQuery.trim().toLowerCase();
-			const limit = parseLimit(args.limit);
-			const results = (await kvInstance.list("mem:memories")).filter((m) => {
-				const text = [
-					typeof m["title"] === "string" ? m["title"] : "",
-					typeof m["content"] === "string" ? m["content"] : "",
-					Array.isArray(m["files"]) ? m["files"].join(" ") : "",
-					Array.isArray(m["concepts"]) ? m["concepts"].join(" ") : "",
-					Array.isArray(m["sessionIds"]) ? m["sessionIds"].join(" ") : "",
-					typeof m["id"] === "string" ? m["id"] : ""
-				].join(" ").toLowerCase();
-				return query.split(/\s+/).every((word) => text.includes(word));
-			}).slice(0, limit);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify(results, null, 2)
-			}] };
+			const query = (v.query || "").toLowerCase();
+			const limit = v.limit ?? DEFAULT_LIMIT;
+			return textResponse({
+				mode: "compact",
+				results: (await kvInstance.list("mem:memories")).filter((m) => {
+					const text = [
+						typeof m["title"] === "string" ? m["title"] : "",
+						typeof m["content"] === "string" ? m["content"] : "",
+						Array.isArray(m["files"]) ? m["files"].join(" ") : "",
+						Array.isArray(m["concepts"]) ? m["concepts"].join(" ") : "",
+						Array.isArray(m["sessionIds"]) ? m["sessionIds"].join(" ") : "",
+						typeof m["id"] === "string" ? m["id"] : ""
+					].join(" ").toLowerCase();
+					return query.split(/\s+/).every((word) => text.includes(word));
+				}).slice(0, limit)
+			}, true);
 		}
 		case "memory_sessions": {
 			const sessions = await kvInstance.list("mem:sessions");
-			const limit = parseLimit(args.limit, 20);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify({ sessions: sessions.slice(0, limit) }, null, 2)
-			}] };
+			const limit = v.limit ?? 20;
+			return textResponse({ sessions: sessions.slice(0, limit) }, true);
 		}
 		case "memory_governance_delete": {
-			const ids = normalizeList(args.memoryIds);
-			if (ids.length === 0) throw new Error("memoryIds is required");
 			let deleted = 0;
-			for (const id of ids) if (await kvInstance.get("mem:memories", id)) {
+			for (const id of v.memoryIds || []) if (await kvInstance.get("mem:memories", id)) {
 				await kvInstance.delete("mem:memories", id);
 				deleted++;
 			}
 			kvInstance.persist();
-			return { content: [{
-				type: "text",
-				text: JSON.stringify({
-					deleted,
-					requested: ids.length,
-					reason: args.reason || "plugin skill request"
-				})
-			}] };
-		}
-		case "memory_export": {
-			const memories = await kvInstance.list("mem:memories");
-			const sessions = await kvInstance.list("mem:sessions");
-			return { content: [{
-				type: "text",
-				text: JSON.stringify({
-					version: VERSION,
-					memories,
-					sessions
-				}, null, 2)
-			}] };
+			return textResponse({
+				deleted,
+				requested: (v.memoryIds || []).length,
+				reason: v.reason
+			});
 		}
+		case "memory_export": return textResponse({
+			version: VERSION,
+			memories: await kvInstance.list("mem:memories"),
+			sessions: await kvInstance.list("mem:sessions")
+		}, true);
 		case "memory_audit": {
 			const entries = await kvInstance.list("mem:audit");
-			const limit = parseLimit(args.limit, 50);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify(entries.slice(0, limit), null, 2)
-			}] };
+			const limit = v.limit ?? 50;
+			return textResponse({ entries: entries.slice(0, limit) }, true);
 		}
-		default: throw new Error(`Unknown tool: ${toolName}`);
+		default: throw new Error(`Unknown tool: ${v.tool}`);
+	}
+}
+async function handleToolCall(toolName, args, kvInstance = kv) {
+	const validated = validate(toolName, args);
+	const handle = await resolveHandle();
+	announceMode(handle);
+	if (handle.mode === "proxy") try {
+		return await handleProxy(validated, handle);
+	} catch (err) {
+		process.stderr.write(`[@agentmemory/mcp] proxy call failed for ${toolName}: ${err instanceof Error ? err.message : String(err)}; invalidating handle and falling back to local KV\n`);
+		invalidateHandle();
 	}
+	return handleLocal(validated, kvInstance);
 }
 const transport = createStdioTransport(async (method, params) => {
 	switch (method) {