mr-memory 3.7.5 → 3.7.7

package/index.js

@@ -8,7 +8,7 @@
  * BYOK — provider API keys never touch MemoryRouter.
  */
 import { readFile, lstat, writeFile, copyFile, mkdir } from "node:fs/promises";
-import { deleteMemories, getMemoryStats, ingestMemory, prepareMemory, searchMemory } from "./memoryrouter-api.js";
+import { deleteMemories, getMemoryStats, ingestMemory, prepareMemory, searchMemory, warmupMemory } from "./memoryrouter-api.js";
 import { join, resolve, relative, isAbsolute, sep, dirname } from "node:path";
 import os from "node:os";
 const DEFAULT_ENDPOINT = "https://api.memoryrouter.ai";
@@ -267,7 +267,7 @@ const WORKSPACE_FILES = [
     "TOOLS.md", "AGENTS.md", "SOUL.md", "BOOTSTRAP.md",
 ];
 function openClawConfigPath() {
-    return process.env.OPENCLAW_CONFIG || join(os.homedir(), ".openclaw", "openclaw.json");
+    return process.env.OPENCLAW_CONFIG_PATH || process.env.OPENCLAW_CONFIG || join(os.homedir(), ".openclaw", "openclaw.json");
 }
 async function readOpenClawConfigFile() {
     try {
@@ -292,6 +292,44 @@ async function writeOpenClawConfigFile(config) {
     await writeFile(configPath, `${JSON.stringify(config, null, 2)}
 `, "utf8");
 }
+// ──────────────────────────────────────────────────────
+// Full-replace: disable OpenClaw's native memory search so MemoryRouter
+// owns the memory_search tool (no name conflict, no native embeddings 429).
+// memoryFlush (durable MEMORY.md writes) is intentionally left untouched.
+// Global + subagents: writes agents.defaults.memorySearch.enabled.
+// ──────────────────────────────────────────────────────
+async function setNativeMemorySearchEnabled(enabled) {
+  const config = await readOpenClawConfigFile();
+  config.agents ??= {};
+  config.agents.defaults ??= {};
+  config.agents.defaults.memorySearch ??= {};
+  if (config.agents.defaults.memorySearch.enabled === enabled) return false; // no-op
+  config.agents.defaults.memorySearch.enabled = enabled;
+  await writeOpenClawConfigFile(config);
+  return true;
+}
+
+// Boot-time self-heal: if a key is configured but native search is still on,
+// flip it off so already-installed users are fixed on restart after updating
+// (no need to re-run `openclaw mr <key>`).
+async function selfHealNativeMemorySearch(api) {
+  try {
+    const config = await readOpenClawConfigFile();
+    const ms = config?.agents?.defaults?.memorySearch;
+    if (ms?.enabled === false) return; // already disabled — nothing to do
+    const changed = await setNativeMemorySearchEnabled(false);
+    if (changed) {
+      api.logger.info?.(
+        "memoryrouter: disabled native memory search (full-replace). Restart gateway to apply.",
+      );
+    }
+  } catch (err) {
+    api.logger.info?.(
+      `memoryrouter: self-heal skipped — ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+}
+
 async function updateOpenClawPluginEntry(api, patch) {
     const config = await readOpenClawConfigFile();
     config.plugins ??= {};
@@ -319,6 +357,47 @@ async function setPluginEnabled(api, enabled) {
     }
     await updateOpenClawPluginEntry(api, { enabled });
 }
+async function mergePluginConfig(api, patch) {
+    const current = await readOpenClawConfigFile();
+    const existing = current.plugins?.entries?.[api.id]?.config;
+    await setPluginConfig(api, {
+        ...(existing && typeof existing === "object" && !Array.isArray(existing) ? existing : {}),
+        ...patch,
+    });
+}
+// Keep mr-memory as a first-class plugin config entry without clobbering user settings.
+// OpenClaw doctor validates plugin entries against discoverable manifests, so the entry
+// must be present, enabled, and allowlisted when an allowlist exists.
+async function ensureDoctorSafePluginEntry(api) {
+    try {
+        const config = await readOpenClawConfigFile();
+        const plugins = config.plugins ?? {};
+        const entries = plugins.entries ?? {};
+        const existingEntry = entries[api.id] && typeof entries[api.id] === "object" && !Array.isArray(entries[api.id])
+            ? entries[api.id]
+            : {};
+        const nextPlugins = {
+            ...plugins,
+            entries: {
+                ...entries,
+                [api.id]: {
+                    ...existingEntry,
+                    enabled: true,
+                },
+            },
+        };
+        if (Array.isArray(plugins.allow) && !plugins.allow.includes(api.id)) {
+            nextPlugins.allow = [...plugins.allow, api.id];
+        }
+        const next = { ...config, plugins: nextPlugins };
+        if (JSON.stringify(next.plugins) === JSON.stringify(config.plugins))
+            return;
+        await writeOpenClawConfigFile(next);
+    }
+    catch (err) {
+        api.logger.info?.(`memoryrouter: doctor-safe registration skipped — ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
 /**
  * Read all workspace files and return as a single text blob for token counting.
  */
@@ -396,6 +475,11 @@ const memoryRouterPlugin = {
             return memoryKey;
         }
         const hasAnyKey = !!(memoryKey || (agentKeys && Object.keys(agentKeys).length > 0));
+        void (async () => {
+            await ensureDoctorSafePluginEntry(api);
+            if (hasAnyKey)
+                await selfHealNativeMemorySearch(api);
+        })();
         if (hasAnyKey) {
             if (memoryKey)
                 api.logger.info?.(`memoryrouter: active (key: ${memoryKey.slice(0, 6)}...)`);
@@ -563,6 +647,8 @@ If setting up MemoryRouter for another agent:
                     if (data.context) {
                         const elapsed = Date.now() - startMs;
                         api.logger.info?.(`memoryrouter: injected ${data.memories_found || 0} memories (${data.memory_tokens || 0} tokens, ${elapsed}ms) [llm_input]`);
+                        if (elapsed > 2000 && data.metrics)
+                            log(`memoryrouter: prepare metrics ${JSON.stringify(data.metrics)}`);
                         const wrapped = wrapForInjection(data.context);
                         return { appendSystemContext: wrapped };
                     }
@@ -664,6 +750,8 @@ If setting up MemoryRouter for another agent:
                     if (data.context) {
                         const elapsed = Date.now() - startMs;
                         api.logger.info?.(`memoryrouter: injected ${data.memories_found || 0} memories (${data.memory_tokens || 0} tokens, ${elapsed}ms)`);
+                        if (elapsed > 2000 && data.metrics)
+                            log(`memoryrouter: prepare metrics ${JSON.stringify(data.metrics)}`);
                         const wrapped = wrapForInjection(data.context);
                         return { appendSystemContext: wrapped };
                     }
@@ -879,8 +967,14 @@ If setting up MemoryRouter for another agent:
                     return;
                 }
                 try {
-                    await setPluginConfig(api, { key });
+                    await mergePluginConfig(api, { key });
                     await setPluginEnabled(api, true);
+                    try {
+                        const changed = await setNativeMemorySearchEnabled(false);
+                        if (changed) console.log(`  • Native memory search disabled — MemoryRouter now owns memory_search`);
+                    } catch (err) {
+                        console.error(`  ⚠ Could not disable native memory search: ${err instanceof Error ? err.message : String(err)}`);
+                    }
                     console.log(`✓ MemoryRouter enabled. Key: ${key.slice(0, 6)}...${key.slice(-3)}`);
                     console.log(`  • memory_search + memory_get tools registered via plugin`);
                     console.log(`\nRun: openclaw mr upload    to upload your memories`);
@@ -913,6 +1007,13 @@ If setting up MemoryRouter for another agent:
                     // This avoids the catch-22 where disabling the plugin removes the `mr` command
                     await setPluginConfig(api, {});
                     // Note: we intentionally do NOT call setPluginEnabled(api, false)
+                    // Restore native memory search so the user isn't left with NO memory search.
+                    try {
+                        const changed = await setNativeMemorySearchEnabled(true);
+                        if (changed) console.log("  • Native memory search restored");
+                    } catch (err) {
+                        console.error(`  ⚠ Could not restore native memory search: ${err instanceof Error ? err.message : String(err)}`);
+                    }
                     console.log("✓ MemoryRouter disabled (key cleared).");
                     console.log("  • CLI still available — run `openclaw mr <key>` to re-enable");
                 }
@@ -942,7 +1043,7 @@ If setting up MemoryRouter for another agent:
                         return;
                     }
                     try {
-                        await setPluginConfig(api, { key: memoryKey, endpoint: cfg?.endpoint, density: name });
+                        await mergePluginConfig(api, { key: memoryKey, density: name });
                         console.log(`✓ Memory density set to ${name}`);
                     }
                     catch (err) {
@@ -960,11 +1061,8 @@ If setting up MemoryRouter for another agent:
                 }
                 const newLogging = !logging;
                 try {
-                    await setPluginConfig(api, {
+                    await mergePluginConfig(api, {
                         key: memoryKey,
-                        endpoint: cfg?.endpoint,
-                        density,
-                        mode,
                         logging: newLogging,
                     });
                     console.log(`✓ Logging ${newLogging ? "ON" : "OFF"} (restart gateway to apply)`);
@@ -1117,8 +1215,17 @@ If setting up MemoryRouter for another agent:
             start: () => {
                 if (memoryKey)
                     api.logger.info?.(`memoryrouter: active (key: ${memoryKey.slice(0, 6)}...)`);
+                if (hasAnyKey && !warmupTimer) {
+                    pingWarmup("startup");
+                    warmupTimer = setInterval(() => pingWarmup("keepalive"), 4 * 60 * 1000);
+                    warmupTimer.unref?.();
+                }
             },
             stop: () => {
+                if (warmupTimer) {
+                    clearInterval(warmupTimer);
+                    warmupTimer = undefined;
+                }
                 api.logger.info?.("memoryrouter: stopped");
             },
         });

package/index.ts

@@ -9,7 +9,7 @@
  */
 
 import { readFile, readdir, stat, lstat, writeFile, copyFile, mkdir } from "node:fs/promises";
-import { deleteMemories, getMemoryStats, ingestMemory, prepareMemory, searchMemory } from "./memoryrouter-api.js";
+import { deleteMemories, getMemoryStats, ingestMemory, prepareMemory, searchMemory, warmupMemory } from "./memoryrouter-api.js";
 import { join, resolve, relative, isAbsolute, sep, dirname } from "node:path";
 import path from "node:path";
 import os from "node:os";
@@ -296,7 +296,7 @@ type CompatApi = OpenClawPluginApi & {
 type JsonObject = Record<string, any>;
 
 function openClawConfigPath(): string {
-  return process.env.OPENCLAW_CONFIG || join(os.homedir(), ".openclaw", "openclaw.json");
+  return process.env.OPENCLAW_CONFIG_PATH || process.env.OPENCLAW_CONFIG || join(os.homedir(), ".openclaw", "openclaw.json");
 }
 
 async function readOpenClawConfigFile(): Promise<JsonObject> {
@@ -320,6 +320,44 @@ async function writeOpenClawConfigFile(config: JsonObject): Promise<void> {
 `, "utf8");
 }
 
+// ──────────────────────────────────────────────────────
+// Full-replace: disable OpenClaw's native memory search so MemoryRouter
+// owns the memory_search tool (no name conflict, no native embeddings 429).
+// memoryFlush (durable MEMORY.md writes) is intentionally left untouched.
+// Global + subagents: writes agents.defaults.memorySearch.enabled.
+// ──────────────────────────────────────────────────────
+async function setNativeMemorySearchEnabled(enabled: boolean): Promise<boolean> {
+  const config = await readOpenClawConfigFile();
+  config.agents ??= {};
+  config.agents.defaults ??= {};
+  config.agents.defaults.memorySearch ??= {};
+  if (config.agents.defaults.memorySearch.enabled === enabled) return false; // no-op
+  config.agents.defaults.memorySearch.enabled = enabled;
+  await writeOpenClawConfigFile(config);
+  return true;
+}
+
+// Boot-time self-heal: if a key is configured but native search is still on,
+// flip it off so already-installed users are fixed on restart after updating
+// (no need to re-run `openclaw mr <key>`).
+async function selfHealNativeMemorySearch(api: OpenClawPluginApi): Promise<void> {
+  try {
+    const config = await readOpenClawConfigFile();
+    const ms = config?.agents?.defaults?.memorySearch;
+    if (ms?.enabled === false) return; // already disabled — nothing to do
+    const changed = await setNativeMemorySearchEnabled(false);
+    if (changed) {
+      api.logger.info?.(
+        "memoryrouter: disabled native memory search (full-replace). Restart gateway to apply.",
+      );
+    }
+  } catch (err) {
+    api.logger.info?.(
+      `memoryrouter: self-heal skipped — ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+}
+
 async function updateOpenClawPluginEntry(api: OpenClawPluginApi, patch: JsonObject): Promise<void> {
   const config = await readOpenClawConfigFile();
   config.plugins ??= {};
@@ -350,6 +388,47 @@ async function setPluginEnabled(api: OpenClawPluginApi, enabled: boolean): Promi
   await updateOpenClawPluginEntry(api, { enabled });
 }
 
+async function mergePluginConfig(api: OpenClawPluginApi, patch: Record<string, unknown>): Promise<void> {
+  const current = await readOpenClawConfigFile();
+  const existing = current.plugins?.entries?.[api.id]?.config;
+  await setPluginConfig(api, {
+    ...(existing && typeof existing === "object" && !Array.isArray(existing) ? existing : {}),
+    ...patch,
+  });
+}
+
+// Keep mr-memory as a first-class plugin config entry without clobbering user settings.
+// OpenClaw doctor validates plugin entries against discoverable manifests, so the entry
+// must be present, enabled, and allowlisted when an allowlist exists.
+async function ensureDoctorSafePluginEntry(api: OpenClawPluginApi): Promise<void> {
+  try {
+    const config = await readOpenClawConfigFile();
+    const plugins = config.plugins ?? {};
+    const entries = plugins.entries ?? {};
+    const existingEntry = entries[api.id] && typeof entries[api.id] === "object" && !Array.isArray(entries[api.id])
+      ? entries[api.id]
+      : {};
+    const nextPlugins: JsonObject = {
+      ...plugins,
+      entries: {
+        ...entries,
+        [api.id]: {
+          ...existingEntry,
+          enabled: true,
+        },
+      },
+    };
+    if (Array.isArray(plugins.allow) && !plugins.allow.includes(api.id)) {
+      nextPlugins.allow = [...plugins.allow, api.id];
+    }
+    const next = { ...config, plugins: nextPlugins };
+    if (JSON.stringify(next.plugins) === JSON.stringify(config.plugins)) return;
+    await writeOpenClawConfigFile(next);
+  } catch (err) {
+    api.logger.info?.(`memoryrouter: doctor-safe registration skipped — ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+
 /**
  * Read all workspace files and return as a single text blob for token counting.
  */
@@ -422,6 +501,40 @@ const memoryRouterPlugin = {
     }
 
     const hasAnyKey = !!(memoryKey || (agentKeys && Object.keys(agentKeys).length > 0));
+    let warmupTimer: ReturnType<typeof setInterval> | undefined;
+
+    function configuredKeys(): string[] {
+      const keys = new Set<string>();
+      if (memoryKey) keys.add(memoryKey);
+      if (agentKeys) {
+        for (const key of Object.values(agentKeys)) {
+          if (key) keys.add(key);
+        }
+      }
+      return Array.from(keys);
+    }
+
+    function pingWarmup(reason: string): void {
+      for (const key of configuredKeys()) {
+        warmupMemory(endpoint, key, embeddings)
+          .then(async (res) => {
+            if (!res.ok) {
+              log(`memoryrouter: warmup ${reason} failed (${res.status})`);
+              return;
+            }
+            const data = await res.json().catch(() => null) as any;
+            log(`memoryrouter: warmup ${reason} ok (${data?.totalVectors ?? 0} vectors, ${data?.warmupTimeMs ?? "?"}ms)`);
+          })
+          .catch((err) => {
+            log(`memoryrouter: warmup ${reason} error — ${err instanceof Error ? err.message : String(err)}`);
+          });
+      }
+    }
+
+    void (async () => {
+      await ensureDoctorSafePluginEntry(api);
+      if (hasAnyKey) await selfHealNativeMemorySearch(api);
+    })();
 
     if (hasAnyKey) {
       if (memoryKey) api.logger.info?.(`memoryrouter: active (key: ${memoryKey.slice(0, 6)}...)`);
@@ -592,11 +705,13 @@ If setting up MemoryRouter for another agent:
             memories_found?: number;
             tokens_billed?: number;
             memory_tokens?: number;
+            metrics?: Record<string, unknown>;
           };
 
           if (data.context) {
             const elapsed = Date.now() - startMs;
             api.logger.info?.(`memoryrouter: injected ${data.memories_found || 0} memories (${data.memory_tokens || 0} tokens, ${elapsed}ms) [llm_input]`);
+            if (elapsed > 2000 && data.metrics) log(`memoryrouter: prepare metrics ${JSON.stringify(data.metrics)}`);
             const wrapped = wrapForInjection(data.context);
             return { appendSystemContext: wrapped };
           }
@@ -704,11 +819,13 @@ If setting up MemoryRouter for another agent:
             memories_found?: number;
             tokens_billed?: number;
             memory_tokens?: number;
+            metrics?: Record<string, unknown>;
           };
 
           if (data.context) {
             const elapsed = Date.now() - startMs;
             api.logger.info?.(`memoryrouter: injected ${data.memories_found || 0} memories (${data.memory_tokens || 0} tokens, ${elapsed}ms)`);
+            if (elapsed > 2000 && data.metrics) log(`memoryrouter: prepare metrics ${JSON.stringify(data.metrics)}`);
             const wrapped = wrapForInjection(data.context);
             return { appendSystemContext: wrapped };
           }
@@ -933,8 +1050,14 @@ If setting up MemoryRouter for another agent:
             return;
           }
           try {
-            await setPluginConfig(api, { key });
+            await mergePluginConfig(api, { key });
             await setPluginEnabled(api, true);
+            try {
+              const changed = await setNativeMemorySearchEnabled(false);
+              if (changed) console.log(`  • Native memory search disabled — MemoryRouter now owns memory_search`);
+            } catch (err) {
+              console.error(`  ⚠ Could not disable native memory search: ${err instanceof Error ? err.message : String(err)}`);
+            }
             console.log(`✓ MemoryRouter enabled. Key: ${key.slice(0, 6)}...${key.slice(-3)}`);
             console.log(`  • memory_search + memory_get tools registered via plugin`);
             console.log(`\nRun: openclaw mr upload    to upload your memories`);
@@ -966,6 +1089,13 @@ If setting up MemoryRouter for another agent:
               // This avoids the catch-22 where disabling the plugin removes the `mr` command
               await setPluginConfig(api, {});
               // Note: we intentionally do NOT call setPluginEnabled(api, false)
+              // Restore native memory search so the user isn't left with NO memory search.
+              try {
+                const changed = await setNativeMemorySearchEnabled(true);
+                if (changed) console.log("  • Native memory search restored");
+              } catch (err) {
+                console.error(`  ⚠ Could not restore native memory search: ${err instanceof Error ? err.message : String(err)}`);
+              }
               console.log("✓ MemoryRouter disabled (key cleared).");
               console.log("  • CLI still available — run `openclaw mr <key>` to re-enable");
             } catch (err) {
@@ -993,7 +1123,7 @@ If setting up MemoryRouter for another agent:
             .action(async () => {
               if (!memoryKey) { console.error("Not configured. Run: openclaw mr <key>"); return; }
               try {
-                await setPluginConfig(api, { key: memoryKey, endpoint: cfg?.endpoint, density: name });
+                await mergePluginConfig(api, { key: memoryKey, density: name });
                 console.log(`✓ Memory density set to ${name}`);
               } catch (err) {
                 console.error(`Failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -1011,11 +1141,8 @@ If setting up MemoryRouter for another agent:
             }
             const newLogging = !logging;
             try {
-              await setPluginConfig(api, {
+              await mergePluginConfig(api, {
                 key: memoryKey,
-                endpoint: cfg?.endpoint,
-                density,
-                mode,
                 logging: newLogging,
               });
               console.log(`✓ Logging ${newLogging ? "ON" : "OFF"} (restart gateway to apply)`);
@@ -1184,8 +1311,17 @@ If setting up MemoryRouter for another agent:
       id: "mr-memory",
       start: () => {
         if (memoryKey) api.logger.info?.(`memoryrouter: active (key: ${memoryKey.slice(0, 6)}...)`);
+        if (hasAnyKey && !warmupTimer) {
+          pingWarmup("startup");
+          warmupTimer = setInterval(() => pingWarmup("keepalive"), 4 * 60 * 1000);
+          warmupTimer.unref?.();
+        }
       },
       stop: () => {
+        if (warmupTimer) {
+          clearInterval(warmupTimer);
+          warmupTimer = undefined;
+        }
         api.logger.info?.("memoryrouter: stopped");
       },
     });

package/memoryrouter-api.js

@@ -47,3 +47,14 @@ export async function deleteMemories(endpoint, key, embeddings) {
         headers: { Authorization: `Bearer ${key}` },
     });
 }
+
+export async function warmupMemory(endpoint, key, embeddings) {
+    return fetch(`${endpoint}/v1/memory/warmup`, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${key}`,
+            ...(embeddings && { "X-Embedding-Model": embeddings }),
+        },
+        signal: AbortSignal.timeout(15000),
+    });
+}

package/memoryrouter-api.ts

@@ -58,3 +58,14 @@ export async function deleteMemories(endpoint: string, key: string, embeddings?:
     headers: { Authorization: `Bearer ${key}` },
   });
 }
+
+export async function warmupMemory(endpoint: string, key: string, embeddings?: string): Promise<Response> {
+  return fetch(`${endpoint}/v1/memory/warmup`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${key}`,
+      ...(embeddings && { "X-Embedding-Model": embeddings }),
+    },
+    signal: AbortSignal.timeout(15000),
+  });
+}

package/openclaw.plugin.json

@@ -46,6 +46,14 @@
         "type": "string",
         "enum": ["bge", "qwen"],
         "description": "Embedding model: bge (1024d, default) or qwen (4096d)"
+      },
+      "agentKeys": {
+        "type": "object",
+        "additionalProperties": {
+          "type": "string",
+          "pattern": "^mk[_-]"
+        },
+        "description": "Optional per-agent MemoryRouter keys, keyed by OpenClaw agent id"
       }
     },
     "required": []

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mr-memory",
-  "version": "3.7.5",
+  "version": "3.7.7",
   "description": "mr-memory is the MemoryRouter plugin for OpenClaw — persistent memory across every conversation",
   "type": "module",
   "files": [