mr-memory 2.7.0 → 2.8.0

package/index.ts

@@ -8,33 +8,23 @@
  * BYOK — provider API keys never touch MemoryRouter.
  */
 
-import { readFile, readdir, stat } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { spawn } from "node:child_process";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 
 const DEFAULT_ENDPOINT = "https://api.memoryrouter.ai";
 
-/** Wrap raw memory context in XML tags with a strong instruction */
-/** Wrap API response in extraction markers so we can strip it next turn. */
-function wrapForInjection(context: string): string {
-  return `<mr-memory>\n${context}\n</mr-memory>`;
-}
-
-/** Strip previous memory injections from message text to prevent stacking.
- *  prependContext persists in conversation history — without stripping,
- *  each turn accumulates another full injection (~20K tokens). */
-const MEMORY_TAG_RE = /<mr-memory>[\s\S]*?<\/mr-memory>\s*/g;
-/** Legacy tag pattern for backward compat (pre-2.7.0 injections still in history) */
-const LEGACY_TAG_RE = /<memory_context>[\s\S]*?<\/memory_context>\s*(?:The above are retrieved memories|IMPORTANT: The above block contains retrieved memories)[^\n]*\n*/g;
-function stripOldMemory(text: string): string {
-  return text.replace(MEMORY_TAG_RE, "").replace(LEGACY_TAG_RE, "").trim();
-}
-
 // Workspace files OpenClaw loads into the system prompt
 const WORKSPACE_FILES = [
-  "IDENTITY.md", "USER.md", "MEMORY.md", "HEARTBEAT.md",
-  "TOOLS.md", "AGENTS.md", "SOUL.md", "BOOTSTRAP.md",
+  "IDENTITY.md",
+  "USER.md",
+  "MEMORY.md",
+  "HEARTBEAT.md",
+  "TOOLS.md",
+  "AGENTS.md",
+  "SOUL.md",
+  "BOOTSTRAP.md",
 ];
 
 type MemoryRouterConfig = {
@@ -42,6 +32,7 @@ type MemoryRouterConfig = {
   endpoint?: string;
   density?: "low" | "high" | "xhigh";
   mode?: "relay" | "proxy";
+  logging?: boolean;
 };
 
 // ──────────────────────────────────────────────────────
@@ -65,7 +56,9 @@ async function runOpenClawConfigSet(path: string, value: string, json = false):
       env: process.env,
     });
     let stderr = "";
-    child.stderr.on("data", (chunk) => { stderr += String(chunk); });
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
     child.on("error", reject);
     child.on("close", (code) => {
       if (code === 0) resolve();
@@ -79,7 +72,10 @@ type CompatApi = OpenClawPluginApi & {
   updatePluginEnabled?: (enabled: boolean) => Promise<void>;
 };
 
-async function setPluginConfig(api: OpenClawPluginApi, config: Record<string, unknown>): Promise<void> {
+async function setPluginConfig(
+  api: OpenClawPluginApi,
+  config: Record<string, unknown>,
+): Promise<void> {
   const compat = api as CompatApi;
   if (typeof compat.updatePluginConfig === "function") {
     await compat.updatePluginConfig(config);
@@ -106,7 +102,9 @@ async function readWorkspaceFiles(workspaceDir: string): Promise<string> {
     try {
       const content = await readFile(join(workspaceDir, file), "utf8");
       if (content.trim()) parts.push(`## ${file}\n${content}`);
-    } catch { /* file doesn't exist — skip */ }
+    } catch {
+      /* file doesn't exist — skip */
+    }
   }
   return parts.join("\n\n");
 }
@@ -119,7 +117,9 @@ function serializeToolsConfig(config: Record<string, unknown>): string {
   if (!tools) return "";
   try {
     return `## Tools Config\n${JSON.stringify(tools, null, 2)}`;
-  } catch { return ""; }
+  } catch {
+    return "";
+  }
 }
 
 /**
@@ -131,7 +131,9 @@ function serializeSkillsConfig(config: Record<string, unknown>): string {
   try {
     const names = Object.keys(skills);
     return `## Skills (${names.length})\n${names.join(", ")}`;
-  } catch { return ""; }
+  } catch {
+    return "";
+  }
 }
 
 // ──────────────────────────────────────────────────────
@@ -149,6 +151,8 @@ const memoryRouterPlugin = {
     const memoryKey = cfg?.key;
     const density = cfg?.density || "high";
     const mode = cfg?.mode || "relay";
+    const logging = cfg?.logging ?? false; // off by default
+    const log = (msg: string) => { if (logging) api.logger.info?.(msg); };
 
     if (memoryKey) {
       api.logger.info?.(`memoryrouter: active (key: ${memoryKey.slice(0, 6)}..., mode: ${mode})`);
@@ -161,28 +165,42 @@ const memoryRouterPlugin = {
     // ==================================================================
 
     if (memoryKey) {
-      // Track whether we've already fired for this prompt (dedup double-fire)
-      let lastPreparedPrompt = "";
-      // Track whether before_prompt_build already handled the first call in this run
-      let promptBuildFiredThisRun = false;
+      // Track prompt-build dedupe independently from llm_input dedupe.
+      let lastPromptBuildPrompt = "";
+      // Skip exactly one matching llm_input after a successful before_prompt_build call.
+      let skipNextLlmInput: { prompt: string; sessionKey?: string } | null = null;
+      // Deduplicate repeated llm_input events without suppressing unrelated calls.
+      let lastLlmInputSignature = "";
 
       // ── llm_input: fires on EVERY LLM call (tool iterations, cron, sub-agents)
       // On stock OpenClaw, the return value is ignored (fire-and-forget).
       // When PR #24122 merges, OpenClaw will use the returned prependContext.
       // This gives forward compatibility — no plugin update needed.
       api.on("llm_input", async (event, ctx) => {
-        api.logger.warn?.(`memoryrouter: llm_input fired (sessionKey=${ctx.sessionKey}, promptBuildFired=${promptBuildFiredThisRun})`);
-        // Skip the first call — before_prompt_build already handled it
-        // (before_prompt_build includes workspace+tools+skills for accurate billing)
-        if (promptBuildFiredThisRun) {
-          promptBuildFiredThisRun = false; // reset so subsequent calls go through
-          return;
-        }
-
         try {
           const prompt = event.prompt;
-          if (prompt === lastPreparedPrompt && lastPreparedPrompt !== "") return;
-          lastPreparedPrompt = prompt;
+
+          // Skip one duplicate llm_input right after a successful before_prompt_build.
+          if (
+            skipNextLlmInput &&
+            skipNextLlmInput.prompt === prompt &&
+            skipNextLlmInput.sessionKey === ctx.sessionKey
+          ) {
+            skipNextLlmInput = null;
+            return;
+          }
+          if (skipNextLlmInput && skipNextLlmInput.sessionKey !== ctx.sessionKey) {
+            skipNextLlmInput = null;
+          }
+
+          // Dedupe exact repeated llm_input events only (same run/session/prompt/history size).
+          const llmInputSignature = [
+            ctx.sessionKey || "",
+            prompt,
+            String(Array.isArray(event.historyMessages) ? event.historyMessages.length : 0),
+          ].join("|");
+          if (llmInputSignature === lastLlmInputSignature) return;
+          lastLlmInputSignature = llmInputSignature;
 
           // Build lightweight context (no workspace/tools — just history + prompt)
           const contextPayload: Array<{ role: string; content: string }> = [];
@@ -194,16 +212,14 @@ const memoryRouterPlugin = {
               if (typeof m.content === "string") text = m.content;
               else if (Array.isArray(m.content)) {
                 text = (m.content as Array<{ type?: string; text?: string }>)
-                  .filter(b => b.type === "text" && b.text)
-                  .map(b => b.text!)
+                  .filter((b) => b.type === "text" && b.text)
+                  .map((b) => b.text!)
                   .join("\n");
               }
-              // Strip old memory injections to prevent stacking
-              if (text) contextPayload.push({ role: m.role, content: m.role === "user" ? stripOldMemory(text) : text });
+              if (text) contextPayload.push({ role: m.role, content: text });
             }
           }
-          contextPayload.push({ role: "user", content: stripOldMemory(prompt) });
-
+          contextPayload.push({ role: "user", content: prompt });
 
           const res = await fetch(`${endpoint}/v1/memory/prepare`, {
             method: "POST",
@@ -215,11 +231,15 @@ const memoryRouterPlugin = {
               messages: contextPayload,
               session_id: ctx.sessionKey,
               density,
-              
             }),
           });
 
-          if (!res.ok) return;
+          if (!res.ok) {
+            const details = await res.text().catch(() => "");
+            const suffix = details ? ` — ${details.slice(0, 200)}` : "";
+            log(`memoryrouter: llm_input prepare failed (${res.status})${suffix}`);
+            return;
+          }
 
           const data = (await res.json()) as {
             context?: string;
@@ -228,28 +248,26 @@ const memoryRouterPlugin = {
           };
 
           if (data.context) {
-            api.logger.info?.(
-              `memoryrouter: injected ${data.memories_found || 0} memories on tool iteration (${data.tokens_billed || 0} tokens billed)`,
-            );
-            return { prependContext: wrapForInjection(data.context) };
+            log(`memoryrouter: injected ${data.memories_found || 0} memories on tool iteration (${data.tokens_billed || 0} tokens)`);
+            // llm_input is typed as void on current OpenClaw builds; cast keeps
+            // runtime forward-compat for builds that consume prependContext.
+            return { prependContext: data.context } as unknown as void;
           }
-        } catch {
-          // Silent fail on tool iterations — don't block the agent
+        } catch (err) {
+          log(`memoryrouter: llm_input prepare error — ${err instanceof Error ? err.message : String(err)}`);
         }
       });
 
       // ── before_prompt_build: fires once per run (primary, includes full billing context)
       api.on("before_prompt_build", async (event, ctx) => {
-        promptBuildFiredThisRun = true;
-        api.logger.warn?.(`memoryrouter: before_prompt_build fired (sessionKey=${ctx.sessionKey}, promptLen=${event.prompt?.length})`);
         try {
           const prompt = event.prompt;
 
-          // Deduplicate — if we already prepared this exact prompt, skip
-          if (prompt === lastPreparedPrompt && lastPreparedPrompt !== "") {
+          // Dedupe only within before_prompt_build path.
+          if (prompt === lastPromptBuildPrompt && lastPromptBuildPrompt !== "") {
             return;
           }
-          lastPreparedPrompt = prompt;
+          lastPromptBuildPrompt = prompt;
 
           // 1. Read workspace files for full token count
           const workspaceDir = ctx.workspaceDir || "";
@@ -260,7 +278,9 @@ const memoryRouterPlugin = {
 
           // 2. Serialize tools + skills from config
           const toolsText = serializeToolsConfig(api.config as unknown as Record<string, unknown>);
-          const skillsText = serializeSkillsConfig(api.config as unknown as Record<string, unknown>);
+          const skillsText = serializeSkillsConfig(
+            api.config as unknown as Record<string, unknown>,
+          );
 
           // 3. Build full context payload (messages + workspace + tools + skills)
           const contextPayload: Array<{ role: string; content: string }> = [];
@@ -273,33 +293,29 @@ const memoryRouterPlugin = {
 
           // Add conversation history
           if (event.messages && Array.isArray(event.messages)) {
-            let skipped = 0;
             for (const msg of event.messages) {
               const m = msg as { role?: string; content?: unknown };
               if (!m.role) continue;
-              
+
               let text = "";
               if (typeof m.content === "string") {
                 text = m.content;
               } else if (Array.isArray(m.content)) {
                 // Handle Anthropic-style content blocks [{type:"text", text:"..."}, ...]
                 text = (m.content as Array<{ type?: string; text?: string }>)
-                  .filter(b => b.type === "text" && b.text)
-                  .map(b => b.text!)
+                  .filter((b) => b.type === "text" && b.text)
+                  .map((b) => b.text!)
                   .join("\n");
               }
-              
+
               if (text) {
-                // Strip old memory injections to prevent stacking
-                contextPayload.push({ role: m.role, content: m.role === "user" ? stripOldMemory(text) : text });
-              } else {
-                skipped++;
+                contextPayload.push({ role: m.role, content: text });
               }
             }
           }
 
-          // Add current user prompt (strip any residual memory tags)
-          contextPayload.push({ role: "user", content: stripOldMemory(prompt) });
+          // Add current user prompt
+          contextPayload.push({ role: "user", content: prompt });
 
           // 4. Call /v1/memory/prepare
 
@@ -313,15 +329,17 @@ const memoryRouterPlugin = {
               messages: contextPayload,
               session_id: ctx.sessionKey,
               density,
-              
             }),
           });
 
           if (!res.ok) {
-            api.logger.warn?.(`memoryrouter: prepare failed (${res.status})`);
+            log(`memoryrouter: prepare failed (${res.status})`);
             return;
           }
 
+          // Suppress the immediately-following duplicate llm_input for this prompt/session.
+          skipNextLlmInput = { prompt, sessionKey: ctx.sessionKey };
+
           const data = (await res.json()) as {
             context?: string;
             memories_found?: number;
@@ -329,15 +347,11 @@ const memoryRouterPlugin = {
           };
 
           if (data.context) {
-            api.logger.info?.(
-              `memoryrouter: injected ${data.memories_found || 0} memories (${data.tokens_billed || 0} tokens billed)`,
-            );
-            return { prependContext: wrapForInjection(data.context) };
+            log(`memoryrouter: injected ${data.memories_found || 0} memories (${data.tokens_billed || 0} tokens)`);
+            return { prependContext: data.context };
           }
         } catch (err) {
-          api.logger.warn?.(
-            `memoryrouter: prepare error — ${err instanceof Error ? err.message : String(err)}`,
-          );
+          log(`memoryrouter: prepare error — ${err instanceof Error ? err.message : String(err)}`);
         }
       });
 
@@ -350,13 +364,22 @@ const memoryRouterPlugin = {
           const msgs = event.messages;
           if (!msgs || !Array.isArray(msgs) || msgs.length === 0) return;
 
+          // Default relay behavior: do not store subagent sessions.
+          const sessionKey = ctx.sessionKey || "";
+          if (typeof sessionKey === "string" && sessionKey.includes(":subagent:")) {
+            api.logger.debug?.(
+              `memoryrouter: skipping ingest for subagent session (${sessionKey})`,
+            );
+            return;
+          }
+
           // Extract text from a message (handles string + content block arrays)
           function extractText(content: unknown): string {
             if (typeof content === "string") return content;
             if (Array.isArray(content)) {
               return (content as Array<{ type?: string; text?: string }>)
-                .filter(b => b.type === "text" && b.text)
-                .map(b => b.text!)
+                .filter((b) => b.type === "text" && b.text)
+                .map((b) => b.text!)
                 .join("\n");
             }
             return "";
@@ -385,7 +408,7 @@ const memoryRouterPlugin = {
 
           // Collect ALL assistant messages after the last user message
           const assistantParts: string[] = [];
-          for (let i = (lastUserIdx >= 0 ? lastUserIdx + 1 : 0); i < msgs.length; i++) {
+          for (let i = lastUserIdx >= 0 ? lastUserIdx + 1 : 0; i < msgs.length; i++) {
             const msg = msgs[i] as { role?: string; content?: unknown };
             if (msg.role === "assistant") {
               const text = extractText(msg.content);
@@ -398,36 +421,31 @@ const memoryRouterPlugin = {
 
           if (toStore.length === 0) return;
 
-          // Await the fetch so OpenClaw's runVoidHook keeps the event loop alive.
-          try {
-            const res = await fetch(`${endpoint}/v1/memory/ingest`, {
-              method: "POST",
-              headers: {
-                "Content-Type": "application/json",
-                Authorization: `Bearer ${memoryKey}`,
-              },
-              body: JSON.stringify({
-                messages: toStore,
-                session_id: ctx.sessionKey,
-                model: "unknown",
-              }),
+          // Fire-and-forget: don't block agent completion on memory ingestion.
+          void fetch(`${endpoint}/v1/memory/ingest`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${memoryKey}`,
+            },
+            body: JSON.stringify({
+              messages: toStore,
+              session_id: ctx.sessionKey,
+              model: "unknown",
+            }),
+          })
+            .then(async (res) => {
+              if (!res.ok) {
+                const details = await res.text().catch(() => "");
+                const suffix = details ? ` — ${details.slice(0, 200)}` : "";
+                log(`memoryrouter: ingest failed (${res.status})${suffix}`);
+              }
+            })
+            .catch((err) => {
+              log(`memoryrouter: ingest error — ${err instanceof Error ? err.message : String(err)}`);
             });
-            if (!res.ok) {
-              const details = await res.text().catch(() => "");
-              const suffix = details ? ` — ${details.slice(0, 200)}` : "";
-              api.logger.warn?.(`memoryrouter: ingest failed (${res.status})${suffix}`);
-            } else {
-              api.logger.debug?.(`memoryrouter: ingest accepted (${toStore.length} messages)`);
-            }
-          } catch (err) {
-            api.logger.warn?.(
-              `memoryrouter: ingest error — ${err instanceof Error ? err.message : String(err)}`,
-            );
-          }
         } catch (err) {
-          api.logger.warn?.(
-            `memoryrouter: agent_end error — ${err instanceof Error ? err.message : String(err)}`,
-          );
+          log(`memoryrouter: agent_end error — ${err instanceof Error ? err.message : String(err)}`);
         }
       });
     } // end if (memoryKey)
@@ -459,14 +477,19 @@ const memoryRouterPlugin = {
           .description("MemoryRouter memory commands")
           .argument("[key]", "Your MemoryRouter memory key (mk_xxx)")
           .action(async (key: string | undefined) => {
-            if (!key) { mr.help(); return; }
+            if (!key) {
+              mr.help();
+              return;
+            }
             await applyKey(key);
           });
 
         mr.command("enable")
           .description("Enable MemoryRouter with a memory key (alias)")
           .argument("<key>", "Your MemoryRouter memory key (mk_xxx)")
-          .action(async (key: string) => { await applyKey(key); });
+          .action(async (key: string) => {
+            await applyKey(key);
+          });
 
         mr.command("off")
           .description("Disable MemoryRouter (removes key)")
@@ -476,7 +499,9 @@ const memoryRouterPlugin = {
               await setPluginEnabled(api, false);
               console.log("✓ MemoryRouter disabled.");
             } catch (err) {
-              console.error(`Failed to disable: ${err instanceof Error ? err.message : String(err)}`);
+              console.error(
+                `Failed to disable: ${err instanceof Error ? err.message : String(err)}`,
+              );
             }
           });
 
@@ -489,9 +514,16 @@ const memoryRouterPlugin = {
           mr.command(name)
             .description(desc)
             .action(async () => {
-              if (!memoryKey) { console.error("Not configured. Run: openclaw mr <key>"); return; }
+              if (!memoryKey) {
+                console.error("Not configured. Run: openclaw mr <key>");
+                return;
+              }
               try {
-                await setPluginConfig(api, { key: memoryKey, endpoint: cfg?.endpoint, density: name });
+                await setPluginConfig(api, {
+                  key: memoryKey,
+                  endpoint: cfg?.endpoint,
+                  density: name,
+                });
                 console.log(`✓ Memory density set to ${name}`);
               } catch (err) {
                 console.error(`Failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -499,6 +531,29 @@ const memoryRouterPlugin = {
             });
         }
 
+        // Logging toggle
+        mr.command("logging")
+          .description("Toggle debug logging on/off")
+          .action(async () => {
+            if (!memoryKey) {
+              console.error("Not configured. Run: openclaw mr <key>");
+              return;
+            }
+            const newLogging = !logging;
+            try {
+              await setPluginConfig(api, {
+                key: memoryKey,
+                endpoint: cfg?.endpoint,
+                density,
+                mode,
+                logging: newLogging,
+              });
+              console.log(`✓ Logging ${newLogging ? "ON" : "OFF"} (restart gateway to apply)`);
+            } catch (err) {
+              console.error(`Failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+          });
+
         // Mode commands
         for (const [modeName, modeDesc] of [
           ["relay", "Relay mode — hooks only, works on stock OpenClaw [default]"],
@@ -507,9 +562,17 @@ const memoryRouterPlugin = {
           mr.command(modeName)
             .description(modeDesc)
             .action(async () => {
-              if (!memoryKey) { console.error("Not configured. Run: openclaw mr <key>"); return; }
+              if (!memoryKey) {
+                console.error("Not configured. Run: openclaw mr <key>");
+                return;
+              }
               try {
-                await setPluginConfig(api, { key: memoryKey, endpoint: cfg?.endpoint, density, mode: modeName });
+                await setPluginConfig(api, {
+                  key: memoryKey,
+                  endpoint: cfg?.endpoint,
+                  density,
+                  mode: modeName,
+                });
                 console.log(`✓ Mode set to ${modeName}`);
               } catch (err) {
                 console.error(`Failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -521,14 +584,23 @@ const memoryRouterPlugin = {
           .description("Show MemoryRouter vault stats")
           .option("--json", "JSON output")
           .action(async (opts) => {
-            if (!memoryKey) { console.error("Not configured. Run: openclaw mr <key>"); return; }
+            if (!memoryKey) {
+              console.error("Not configured. Run: openclaw mr <key>");
+              return;
+            }
             try {
               const res = await fetch(`${endpoint}/v1/memory/stats`, {
                 headers: { Authorization: `Bearer ${memoryKey}` },
               });
               const data = (await res.json()) as { totalVectors?: number; totalTokens?: number };
               if (opts.json) {
-                console.log(JSON.stringify({ enabled: true, key: memoryKey, density, mode, stats: data }, null, 2));
+                console.log(
+                  JSON.stringify(
+                    { enabled: true, key: memoryKey, density, mode, stats: data },
+                    null,
+                    2,
+                  ),
+                );
               } else {
                 console.log("MemoryRouter Status");
                 console.log("───────────────────────────");
@@ -550,25 +622,47 @@ const memoryRouterPlugin = {
           .argument("[path]", "Specific file or directory to upload")
           .option("--workspace <dir>", "Workspace directory")
           .option("--brain <dir>", "State directory with sessions")
-          .action(async (targetPath: string | undefined, opts: { workspace?: string; brain?: string }) => {
-            if (!memoryKey) { console.error("Not configured. Run: openclaw mr <key>"); return; }
-            const os = await import("node:os");
-            const path = await import("node:path");
-            const stateDir = opts.brain ? path.resolve(opts.brain) : path.join(os.homedir(), ".openclaw");
-            const configWorkspace = (api.config as any).workspace || (api.config as any).agents?.defaults?.workspace;
-            const workspacePath = opts.workspace
-              ? path.resolve(opts.workspace)
-              : configWorkspace
-                ? path.resolve(configWorkspace.replace(/^~/, os.homedir()))
-                : path.join(os.homedir(), ".openclaw", "workspace");
-            const { runUpload } = await import("./upload.js");
-            await runUpload({ memoryKey, endpoint, targetPath, stateDir, workspacePath, hasWorkspaceFlag: !!opts.workspace, hasBrainFlag: !!opts.brain });
-          });
+          .action(
+            async (
+              targetPath: string | undefined,
+              opts: { workspace?: string; brain?: string },
+            ) => {
+              if (!memoryKey) {
+                console.error("Not configured. Run: openclaw mr <key>");
+                return;
+              }
+              const os = await import("node:os");
+              const path = await import("node:path");
+              const stateDir = opts.brain
+                ? path.resolve(opts.brain)
+                : path.join(os.homedir(), ".openclaw");
+              const configWorkspace =
+                (api.config as any).workspace || (api.config as any).agents?.defaults?.workspace;
+              const workspacePath = opts.workspace
+                ? path.resolve(opts.workspace)
+                : configWorkspace
+                  ? path.resolve(configWorkspace.replace(/^~/, os.homedir()))
+                  : path.join(os.homedir(), ".openclaw", "workspace");
+              const { runUpload } = await import("./upload.js");
+              await runUpload({
+                memoryKey,
+                endpoint,
+                targetPath,
+                stateDir,
+                workspacePath,
+                hasWorkspaceFlag: !!opts.workspace,
+                hasBrainFlag: !!opts.brain,
+              });
+            },
+          );
 
         mr.command("delete")
           .description("Clear all memories from vault")
           .action(async () => {
-            if (!memoryKey) { console.error("Not configured. Run: openclaw mr <key>"); return; }
+            if (!memoryKey) {
+              console.error("Not configured. Run: openclaw mr <key>");
+              return;
+            }
             try {
               const res = await fetch(`${endpoint}/v1/memory`, {
                 method: "DELETE",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mr-memory",
-  "version": "2.7.0",
+  "version": "2.8.0",
   "description": "MemoryRouter persistent memory plugin for OpenClaw — your AI remembers every conversation",
   "type": "module",
   "files": [