mr-memory 1.0.11 → 2.0.0

package/index.ts

@@ -1,11 +1,11 @@
 /**
- * MemoryRouter Plugin for OpenClaw
+ * MemoryRouter Plugin for OpenClaw (v2 — Relay Architecture)
  *
  * Persistent AI memory via MemoryRouter (memoryrouter.ai).
- * Routes LLM calls through MemoryRouter's API which injects relevant
- * past context and captures conversations automatically.
+ * Uses OpenClaw's native plugin hooks (before_agent_start + agent_end)
+ * to inject relevant memories and capture conversations.
  *
- * BYOK — provider API keys pass through untouched.
+ * No patching required. Works with stock OpenClaw.
  */
 
 import { spawn } from "node:child_process";
@@ -19,50 +19,6 @@ type MemoryRouterConfig = {
   density?: 'low' | 'high' | 'xhigh';
 };
 
-type CompatApi = OpenClawPluginApi & {
-  updatePluginConfig?: (config: Record<string, unknown>) => Promise<void>;
-  updatePluginEnabled?: (enabled: boolean) => Promise<void>;
-};
-
-/**
- * Supported provider APIs that MemoryRouter can proxy.
- */
-const SUPPORTED_APIS = new Set([
-  "anthropic-messages",
-  "openai-completions",
-  "openai-responses",
-  "azure-openai-responses",
-  "ollama",
-]);
-
-/**
- * Detect if the current LLM call is a tool-use iteration (not direct user conversation).
- * Tool iterations have tool_result (Anthropic) or tool-role (OpenAI) messages
- * after the last real user message.
- */
-function isToolUseIteration(context: { messages?: Array<{ role: string; content?: unknown }> }): boolean {
-  const messages = context.messages;
-  if (!messages || messages.length === 0) return false;
-
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const msg = messages[i];
-
-    if (msg.role === "tool") return true;
-
-    if (msg.role === "user" && Array.isArray(msg.content)) {
-      const hasToolResult = (msg.content as Array<{ type?: string }>).some(
-        (block) => block.type === "tool_result",
-      );
-      if (hasToolResult) return true;
-    }
-
-    if (msg.role === "user" && typeof msg.content === "string") return false;
-    if (msg.role === "assistant") continue;
-  }
-
-  return false;
-}
-
 function resolveOpenClawInvocation(): { command: string; args: string[] } {
   const entry = process.argv[1];
   if (entry) {
@@ -108,9 +64,9 @@ async function runOpenClawConfigSet(path: string, value: string, json = false):
 }
 
 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);
+  const anyApi = api as any;
+  if (typeof anyApi.updatePluginConfig === "function") {
+    await anyApi.updatePluginConfig(config);
     return;
   }
 
@@ -118,9 +74,9 @@ async function setPluginConfig(api: OpenClawPluginApi, config: Record<string, un
 }
 
 async function setPluginEnabled(api: OpenClawPluginApi, enabled: boolean): Promise<void> {
-  const compat = api as CompatApi;
-  if (typeof compat.updatePluginEnabled === "function") {
-    await compat.updatePluginEnabled(enabled);
+  const anyApi = api as any;
+  if (typeof anyApi.updatePluginEnabled === "function") {
+    await anyApi.updatePluginEnabled(enabled);
     return;
   }
 
@@ -139,7 +95,7 @@ const memoryRouterPlugin = {
     const density = cfg?.density || 'high';
 
     // ==================================================================
-    // Core: Route LLM calls through MemoryRouter (only when key is set)
+    // Core: Relay architecture — memory via API hooks (no patching needed)
     // ==================================================================
 
     if (memoryKey) {
@@ -149,41 +105,114 @@ const memoryRouterPlugin = {
     }
 
     if (memoryKey) {
-      api.registerStreamFnWrapper((next) => {
-      return (model, context, options) => {
-        // Only proxy supported APIs
-        if (!SUPPORTED_APIS.has(model.api)) {
-          return next(model, context, options);
+      // RETRIEVAL — inject relevant memories before every agent turn
+      api.on("before_agent_start", async (event: Record<string, unknown>) => {
+        const prompt = event.prompt as string | undefined;
+        if (!prompt || prompt.length < 5) return;
+
+        try {
+          const res = await fetch(`${endpoint}/v1/memory/prepare`, {
+            method: "POST",
+            headers: {
+              "Authorization": `Bearer ${memoryKey}`,
+              "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+              messages: [{ role: "user", content: prompt }],
+              density,
+            }),
+          });
+
+          if (!res.ok) {
+            api.logger.warn?.(`memoryrouter: prepare failed (${res.status})`);
+            return;
+          }
+
+          const data = await res.json() as { context: string | null; tokens_billed: number; memories_found: number };
+
+          if (data.context) {
+            api.logger.info?.(`memoryrouter: injected ${data.memories_found} memories (${data.tokens_billed} tokens)`);
+            return { prependContext: data.context };
+          }
+        } catch (err) {
+          api.logger.warn?.(`memoryrouter: prepare error: ${String(err)}`);
         }
+      });
+
+      // STORAGE — capture conversation after every agent turn
+      // Only stores the LAST user message + assistant response per turn (no duplication)
+      api.on("agent_end", async (event: Record<string, unknown>) => {
+        if (!event.success || !event.messages) return;
+
+        const msgs = event.messages as Array<Record<string, unknown>>;
+        if (!msgs.length) return;
+
+        try {
+          // Walk backwards: find the last assistant, then the last user before it
+          let assistantMsg: { role: string; content: string } | null = null;
+          let userMsg: { role: string; content: string } | null = null;
+
+          for (let i = msgs.length - 1; i >= 0; i--) {
+            const role = msgs[i].role as string;
+            if (!role) continue;
+
+            // Extract text content
+            let text = "";
+            const content = msgs[i].content;
+            if (typeof content === "string") {
+              text = content;
+            } else if (Array.isArray(content)) {
+              for (const block of content as Array<Record<string, unknown>>) {
+                if (typeof block.text === "string") {
+                  text += (text ? "\n" : "") + block.text;
+                }
+              }
+            }
 
-        // Route through MemoryRouter
-        const mrModel = {
-          ...model,
-          baseUrl: model.api === "anthropic-messages"
-            ? endpoint  // Anthropic: baseUrl is without /v1
-            : `${endpoint}/v1`,
-        };
+            if (!text || text.length < 10) continue;
 
-        // Detect tool iterations — don't store intermediate work
-        const toolIteration = isToolUseIteration(
-          context as { messages?: Array<{ role: string; content?: unknown }> },
-        );
-
-        // Inject MemoryRouter headers
-        const mrOptions = {
-          ...options,
-          headers: {
-            ...options?.headers,
-            "X-Memory-Key": memoryKey,
-            "X-Memory-Store": toolIteration ? "false" : "true",
-            "X-Memory-Density": density,
-          },
-        };
+            if (!assistantMsg && role === "assistant") {
+              assistantMsg = { role, content: text };
+            }
+            if (assistantMsg && !userMsg && role === "user") {
+              // Strip any injected memory context from user messages
+              let cleanText = text;
+              if (cleanText.includes("[Memory Context]")) {
+                cleanText = cleanText.replace(/\[Memory Context\][\s\S]*?\n\n/g, "").trim();
+              }
+              if (cleanText.length >= 10) {
+                userMsg = { role, content: cleanText };
+              }
+              break;
+            }
+          }
 
-        return next(mrModel, context, mrOptions);
-      };
-    });
-    } // end if (memoryKey) for streamFn wrapper
+          // Only store this turn's pair — no duplication
+          const toStore: Array<{ role: string; content: string }> = [];
+          if (userMsg) toStore.push(userMsg);
+          if (assistantMsg) toStore.push(assistantMsg);
+
+          if (toStore.length === 0) return;
+
+          const res = await fetch(`${endpoint}/v1/memory/ingest`, {
+            method: "POST",
+            headers: {
+              "Authorization": `Bearer ${memoryKey}`,
+              "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+              messages: toStore,
+            }),
+          });
+
+          if (!res.ok) {
+            api.logger.warn?.(`memoryrouter: ingest failed (${res.status})`);
+          }
+        } catch (err) {
+          api.logger.warn?.(`memoryrouter: ingest error: ${String(err)}`);
+        }
+      });
+    } // end if (memoryKey) for relay hooks
 
     // ==================================================================
     // CLI Commands (always registered — even without key, for enable/off)

package/package.json

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