@humanlikememory/human-like-mem 0.3.14 → 0.4.0

package/index.js

@@ -6,7 +6,7 @@
  * @license Apache-2.0
  */
 
-const PLUGIN_VERSION = "0.3.4";
+const PLUGIN_VERSION = "0.4.0";
 const USER_QUERY_MARKER = "--- User Query ---";
 
 /**
@@ -35,7 +35,7 @@ function warnMissingApiKey(log) {
 Get your API key from: https://human-like.me
 Then set:
   export HUMAN_LIKE_MEM_API_KEY="mp_xxxxxx"
-  export HUMAN_LIKE_MEM_BASE_URL="https://plugin.human-like.me"
+  export HUMAN_LIKE_MEM_BASE_URL="https://human-like.me"
 `;
   if (log?.warn) {
     log.warn(msg);
@@ -981,257 +981,167 @@ async function flushSession(sessionId, cfg, ctx, log) {
 }
 
 /**
- * Main plugin export.
- * Supports both register(api) style and config -> hooks style.
+ * Main plugin export — object-style with register(api) method.
+ * Supports OpenClaw >=2026.2.0 capability registration.
  */
-export default function(configOrApi) {
-  // register(api) style
-  if (configOrApi && typeof configOrApi === 'object' && typeof configOrApi.on === 'function') {
-    return registerPlugin(configOrApi);
-  }
-
-  // config -> hooks style
-  return createHooksPlugin(configOrApi);
-}
-
-/**
- * Register style plugin (like MemOS)
- */
-function registerPlugin(api) {
-  const config = api.pluginConfig || {};
-  const log = api.logger || console;
+export default {
+  id: "human-like-mem",
+  name: "Human-Like Memory Plugin",
+  kind: "memory",
 
-  const cfg = buildConfig(config);
+  register(api) {
+    const config = api.pluginConfig || {};
+    const log = api.logger || console;
+    const cfg = buildConfig(config);
 
-  const recallHandler = async (event, ctx) => {
-    if (!cfg.recallEnabled) return;
-
-    if (log?.debug) {
-      log.debug(`[Memory Plugin] recall hook TRIGGERED (register mode)`);
-      log.debug(`[Memory Plugin] recall ctx keys: ${JSON.stringify(ctx ? Object.keys(ctx) : 'null')}`);
-      log.debug(`[Memory Plugin] recall event keys: ${JSON.stringify(event ? Object.keys(event) : 'null')}`);
-    }
-
-    const prompt = event?.prompt || "";
-    if (!prompt || prompt.trim().length < 3) {
-      if (log?.debug) log.debug('[Memory Plugin] Prompt too short, skipping recall');
-      return;
+    if (log?.info) {
+      log.info(`[Memory Plugin] v${PLUGIN_VERSION} registering as memory slot`);
     }
 
-    const sessionId = resolveSessionId(ctx, event) || `session-${Date.now()}`;
-    const userContent = normalizeUserMessageContent(prompt);
-    const rawUserContent = stripPrependedPrompt(prompt);
-    if (userContent) {
-      addToSessionCache(sessionId, { role: "user", content: userContent, rawContent: rawUserContent });
-    }
+    // --- Check allowPromptInjection policy ---
+    const pluginEntry = api.config?.plugins?.entries?.[api.id] ?? api.config?.plugins?.entries?.["human-like-mem"];
+    const allowPromptInjection = pluginEntry?.hooks?.allowPromptInjection !== false;
 
-    try {
-      const memories = await retrieveMemory(prompt, cfg, ctx, log);
+    // --- Service lifecycle ---
+    api.registerService({
+      id: "human-like-mem",
+      start: async () => {
+        if (log?.info) log.info(`[Memory Plugin] Service started (v${PLUGIN_VERSION})`);
+      },
+      health: async () => {
+        const hasApiKey = !!(cfg.apiKey || process.env.HUMAN_LIKE_MEM_API_KEY);
+        return {
+          status: hasApiKey ? "ok" : "degraded",
+          message: hasApiKey
+            ? `v${PLUGIN_VERSION} ready, ${sessionCache.size} active sessions`
+            : "API key not configured",
+        };
+      },
+      stop: async () => {
+        if (log?.info) log.info(`[Memory Plugin] Service stopping, flushing ${sessionCache.size} sessions`);
+        const flushPromises = [];
+        for (const [sid] of sessionCache) {
+          flushPromises.push(
+            flushSession(sid, cfg, null, log).catch(err => {
+              if (log?.warn) log.warn(`[Memory Plugin] Flush failed for ${sid}: ${err.message}`);
+            })
+          );
+        }
+        await Promise.allSettled(flushPromises);
+        if (log?.info) log.info(`[Memory Plugin] Service stopped`);
+      },
+    });
 
-      let prependContext = "";
+    // --- Register memory runtime for status reporting ---
+    if (typeof api.registerMemoryRuntime === "function") {
+      api.registerMemoryRuntime({
+        getMemorySearchManager: async () => ({
+          manager: {
+            async probeVectorAvailability() {
+              return { ok: !!(cfg.apiKey || process.env.HUMAN_LIKE_MEM_API_KEY) };
+            },
+            status() {
+              return {
+                files: sessionCache.size,
+                chunks: 0,
+                dirty: false,
+                sources: ["remote-api"],
+                provider: "human-like-mem",
+                vector: { enabled: true, available: true, provider: "remote" },
+              };
+            },
+            async close() {},
+          },
+        }),
+        resolveMemoryBackendConfig: () => ({
+          store: { driver: "remote", path: "remote://plugin.human-like.me" },
+        }),
+      });
+      if (log?.info) log.info(`[Memory Plugin] Registered memory runtime for status reporting`);
+    }
 
-      const upgradeMsg = formatUpgradeNotification();
-      if (upgradeMsg) {
-        prependContext += upgradeMsg + "\n\n";
-        upgradeNotification = null;
+    // --- Recall handler (before_prompt_build only) ---
+    const recallHandler = async (event, ctx) => {
+      if (!cfg.recallEnabled) return;
+      if (!allowPromptInjection) {
+        if (log?.debug) log.debug(`[Memory Plugin] allowPromptInjection=false, auto-recall disabled`);
+        return;
       }
 
-      if (memories && memories.length > 0) {
-        prependContext += formatMemoriesForContext(memories, { currentTime: Date.now() });
-        if (log?.info) log.info(`[Memory Plugin] Injected ${memories.length} memories`);
+      if (log?.debug) {
+        log.debug(`[Memory Plugin] before_prompt_build TRIGGERED`);
+        log.debug(`[Memory Plugin] recall ctx keys: ${JSON.stringify(ctx ? Object.keys(ctx) : 'null')}`);
+        log.debug(`[Memory Plugin] recall event keys: ${JSON.stringify(event ? Object.keys(event) : 'null')}`);
       }
 
-      if (prependContext) {
-        return { prependContext };
+      const prompt = event?.prompt || "";
+      if (!prompt || prompt.trim().length < 3) {
+        if (log?.debug) log.debug('[Memory Plugin] Prompt too short, skipping recall');
+        return;
       }
-    } catch (error) {
-      if (log?.warn) log.warn(`[Memory Plugin] Memory recall failed: ${error.message}`);
 
-      const upgradeMsg = formatUpgradeNotification();
-      if (upgradeMsg) {
-        upgradeNotification = null;
-        return { prependContext: upgradeMsg };
+      const sessionId = resolveSessionId(ctx, event) || `session-${Date.now()}`;
+      const userContent = normalizeUserMessageContent(prompt);
+      const rawUserContent = stripPrependedPrompt(prompt);
+      if (userContent) {
+        addToSessionCache(sessionId, { role: "user", content: userContent, rawContent: rawUserContent });
       }
-    }
-  };
 
-  const storeHandler = async (event, ctx) => {
-    if (!cfg.addEnabled) return;
-    if (!event?.success) return;
+      try {
+        const memories = await retrieveMemory(prompt, cfg, ctx, log);
 
-    if (log?.debug) {
-      log.debug(`[Memory Plugin] store hook ctx keys: ${JSON.stringify(ctx ? Object.keys(ctx) : 'null')}`);
-      log.debug(`[Memory Plugin] store hook event keys: ${JSON.stringify(event ? Object.keys(event) : 'null')}`);
-    }
+        let prependContext = "";
 
-    const sessionId = resolveSessionId(ctx, event);
-    if (!sessionId) {
-      if (log?.debug) log.debug('[Memory Plugin] No session ID found in ctx or event, skipping memory cache');
-      return;
-    }
-
-    const assistantContent = event?.response || event?.result;
-    if (assistantContent) {
-      const content = normalizeAssistantMessageContent(assistantContent);
-      const rawContent = extractText(assistantContent);
-      if (content) {
-        addToSessionCache(sessionId, { role: "assistant", content, rawContent: rawContent || undefined });
-      }
-    } else if (event?.messages?.length) {
-      for (let i = event.messages.length - 1; i >= 0; i--) {
-        if (event.messages[i].role === "assistant") {
-          const content = normalizeAssistantMessageContent(event.messages[i].content);
-          const rawContent = extractText(event.messages[i].content);
-          if (content) {
-            addToSessionCache(sessionId, { role: "assistant", content, rawContent: rawContent || undefined });
-          }
-          break;
+        const upgradeMsg = formatUpgradeNotification();
+        if (upgradeMsg) {
+          prependContext += upgradeMsg + "\n\n";
+          upgradeNotification = null;
         }
-      }
-    }
-
-    scheduleSessionFlush(sessionId, cfg, ctx, log);
 
-    const cache = sessionCache.get(sessionId);
-    if (cache && cache.turnCount >= (cfg.minTurnsToStore || 10)) {
-      if (isConversationWorthStoring(cache.messages, cfg)) {
-        if (log?.info) {
-          log.info(`[Memory Plugin] Reached ${cache.turnCount} turns, flushing session`);
+        if (memories && memories.length > 0) {
+          prependContext += formatMemoriesForContext(memories, { currentTime: Date.now() });
+          if (log?.info) log.info(`[Memory Plugin] Injected ${memories.length} memories`);
         }
-        flushSession(sessionId, cfg, ctx, log).catch(err => {
-          if (log?.warn) log.warn(`[Memory Plugin] Async flush failed: ${err.message}`);
-        });
-      }
-    }
-  };
-
-  const sessionEndHandler = async (event, ctx) => {
-    if (!cfg.addEnabled) return;
-
-    const sessionId = resolveSessionId(ctx, event);
-    if (!sessionId) return;
-
-    if (log?.info) {
-      log.info(`[Memory Plugin] Session ending, flushing cache`);
-    }
-
-    await flushSession(sessionId, cfg, ctx, log);
-  };
 
-  for (const name of ["before_agent_start", "agent_start", "prompt_start", "message_received", "request_pre", "before_recall"]) {
-    api.on(name, recallHandler);
-  }
-  for (const name of ["agent_end", "prompt_end", "request_post", "message_sent"]) {
-    api.on(name, storeHandler);
-  }
-  api.on("session_end", sessionEndHandler);
-}
-
-/**
- * Hooks object style plugin
- */
-function createHooksPlugin(config) {
-  const cfg = buildConfig(config);
-
-  const recallHandler = async (event, ctx) => {
-    const log = ctx?.log || console;
-
-    if (log?.debug) {
-      log.debug(`[Memory Plugin] recall hook TRIGGERED`);
-      log.debug(`[Memory Plugin] recall ctx keys: ${JSON.stringify(ctx ? Object.keys(ctx) : 'null')}`);
-      log.debug(`[Memory Plugin] recall event keys: ${JSON.stringify(event ? Object.keys(event) : 'null')}`);
-    }
-
-    if (!cfg.recallEnabled) return;
-
-    const prompt = event?.prompt || "";
-    if (!prompt || prompt.trim().length < 3) {
-      if (log?.debug) log.debug('[Memory Plugin] Prompt too short, skipping recall');
-      return;
-    }
-
-    const sessionId = resolveSessionId(ctx, event) || `session-${Date.now()}`;
-    const userContent = normalizeUserMessageContent(prompt);
-    const rawUserContent = stripPrependedPrompt(prompt);
-    if (userContent) {
-      addToSessionCache(sessionId, { role: "user", content: userContent, rawContent: rawUserContent });
-    }
-
-    try {
-      const memories = await retrieveMemory(prompt, cfg, ctx, log);
-
-      let prependContext = "";
+        if (prependContext) {
+          return { prependContext };
+        }
+      } catch (error) {
+        if (log?.warn) log.warn(`[Memory Plugin] Memory recall failed: ${error.message}`);
 
-      const upgradeMsg = formatUpgradeNotification();
-      if (upgradeMsg) {
-        prependContext += upgradeMsg + "\n\n";
-        upgradeNotification = null;
+        const upgradeMsg = formatUpgradeNotification();
+        if (upgradeMsg) {
+          upgradeNotification = null;
+          return { prependContext: upgradeMsg };
+        }
       }
+    };
 
-      if (memories && memories.length > 0) {
-        prependContext += formatMemoriesForContext(memories, { currentTime: Date.now() });
-        if (log?.info) log.info(`[Memory Plugin] Injected ${memories.length} memories`);
-      }
+    // --- Store handler (agent_end only) ---
+    const storeHandler = async (event, ctx) => {
+      if (!cfg.addEnabled) return;
+      if (!event?.success) return;
 
-      if (prependContext) {
-        return { prependContext };
+      if (log?.debug) {
+        log.debug(`[Memory Plugin] agent_end store TRIGGERED`);
+        log.debug(`[Memory Plugin] store hook ctx keys: ${JSON.stringify(ctx ? Object.keys(ctx) : 'null')}`);
+        log.debug(`[Memory Plugin] store hook event keys: ${JSON.stringify(event ? Object.keys(event) : 'null')}`);
       }
-    } catch (error) {
-      if (log?.warn) log.warn(`[Memory Plugin] Memory recall failed: ${error.message}`);
 
-      const upgradeMsg = formatUpgradeNotification();
-      if (upgradeMsg) {
-        upgradeNotification = null;
-        return { prependContext: upgradeMsg };
+      const sessionId = resolveSessionId(ctx, event);
+      if (!sessionId) {
+        if (log?.debug) log.debug('[Memory Plugin] No session ID found in ctx or event, skipping memory cache');
+        return;
       }
-    }
-  };
-
-  const storeHandler = async (event, ctx) => {
-    const log = ctx?.log || console;
-
-    if (log?.debug) {
-      log.debug(`[Memory Plugin] store hook ctx keys: ${JSON.stringify(ctx ? Object.keys(ctx) : 'null')}`);
-      log.debug(`[Memory Plugin] store hook event keys: ${JSON.stringify(event ? Object.keys(event) : 'null')}`);
-      if (ctx?.messageProvider) {
-        try {
-          const mpKeys = typeof ctx.messageProvider === 'object' ? Object.keys(ctx.messageProvider) : typeof ctx.messageProvider;
-          log.debug(`[Memory Plugin] messageProvider info: ${JSON.stringify(mpKeys)}`);
-        } catch (_) {}
-      }
-    }
 
-    if (!cfg.addEnabled) return;
-    if (!event?.success) return;
-
-    const sessionId = resolveSessionId(ctx, event);
-    if (!sessionId) {
-      if (log?.debug) log.debug('[Memory Plugin] No session ID found in ctx or event, skipping memory cache');
-      return;
-    }
-
-    if (log?.debug) {
-      log.debug(`[Memory Plugin] Resolved sessionId: ${sessionId}`);
-    }
-
-    // If event.messages has full conversation, cache all of them at once
-    if (event?.messages?.length) {
-      const cache = getSessionCache(sessionId);
-      if (cache.messages.length === 0) {
-        for (const msg of event.messages) {
-          if (msg.role === "system") continue;
-          const content = msg.role === "user"
-            ? normalizeUserMessageContent(msg.content)
-            : normalizeAssistantMessageContent(msg.content);
-          const rawSource = msg.role === "user"
-            ? stripPrependedPrompt(msg.content)
-            : extractText(msg.content);
-          if (content) {
-            addToSessionCache(sessionId, { role: msg.role, content, rawContent: rawSource || undefined });
-          }
+      const assistantContent = event?.response || event?.result;
+      if (assistantContent) {
+        const content = normalizeAssistantMessageContent(assistantContent);
+        const rawContent = extractText(assistantContent);
+        if (content) {
+          addToSessionCache(sessionId, { role: "assistant", content, rawContent: rawContent || undefined });
         }
-      } else {
-        // Only add last assistant message
+      } else if (event?.messages?.length) {
         for (let i = event.messages.length - 1; i >= 0; i--) {
           if (event.messages[i].role === "assistant") {
             const content = normalizeAssistantMessageContent(event.messages[i].content);
@@ -1243,65 +1153,116 @@ function createHooksPlugin(config) {
           }
         }
       }
-    } else {
-      const assistantContent = event?.response || event?.result;
-      if (assistantContent) {
-        const content = normalizeAssistantMessageContent(assistantContent);
-        const rawContent = extractText(assistantContent);
-        if (content) {
-          addToSessionCache(sessionId, { role: "assistant", content, rawContent: rawContent || undefined });
+
+      scheduleSessionFlush(sessionId, cfg, ctx, log);
+
+      const cache = sessionCache.get(sessionId);
+      if (cache && cache.turnCount >= (cfg.minTurnsToStore || 10)) {
+        if (isConversationWorthStoring(cache.messages, cfg)) {
+          if (log?.info) {
+            log.info(`[Memory Plugin] Reached ${cache.turnCount} turns, flushing session`);
+          }
+          flushSession(sessionId, cfg, ctx, log).catch(err => {
+            if (log?.warn) log.warn(`[Memory Plugin] Async flush failed: ${err.message}`);
+          });
         }
       }
-    }
+    };
 
-    scheduleSessionFlush(sessionId, cfg, ctx, log);
+    // --- Session end handler ---
+    const sessionEndHandler = async (event, ctx) => {
+      if (!cfg.addEnabled) return;
 
-    const cache = sessionCache.get(sessionId);
-    if (cache && cache.turnCount >= (cfg.minTurnsToStore || 10)) {
-      if (isConversationWorthStoring(cache.messages, cfg)) {
-        if (log?.info) {
-          log.info(`[Memory Plugin] Reached ${cache.turnCount} turns, flushing session`);
-        }
-        flushSession(sessionId, cfg, ctx, log).catch(err => {
-          if (log?.warn) log.warn(`[Memory Plugin] Async flush failed: ${err.message}`);
-        });
+      const sessionId = resolveSessionId(ctx, event);
+      if (!sessionId) return;
+
+      if (log?.info) {
+        log.info(`[Memory Plugin] Session ending, flushing cache`);
       }
-    }
-  };
 
-  const sessionEndHandler = async (event, ctx) => {
-    const log = ctx?.log || console;
+      await flushSession(sessionId, cfg, ctx, log);
+    };
 
-    if (!cfg.addEnabled) return;
+    // --- Hook registration (single canonical hooks) ---
+    api.on("before_prompt_build", recallHandler);
+    api.on("agent_end", storeHandler);
+    api.on("session_end", sessionEndHandler);
+
+    // --- Agent tools registration ---
+    if (typeof api.registerTool === "function") {
+      api.registerTool({
+        name: "memory_search",
+        label: "Memory Search",
+        description: "Search user's long-term memory for relevant past conversations, knowledge, and preferences. Use this when you need context about the user's history or when they reference past events.",
+        parameters: {
+          type: "object",
+          properties: {
+            query: { type: "string", description: "Search query — keywords or natural language describing what to look for in memory" },
+            limit: { type: "number", description: "Maximum number of results to return (default: 6, max: 20)" },
+          },
+          required: ["query"],
+        },
+        execute: async (_toolCallId, params) => {
+          const { query, limit = 6 } = params;
+          const clampedLimit = Math.min(Math.max(1, limit), 20);
+          if (log?.info) log.info(`[Memory Plugin] Tool memory_search: query="${truncate(query, 50)}", limit=${clampedLimit}`);
+          try {
+            const memories = await retrieveMemory(query, { ...cfg, memoryLimitNumber: clampedLimit }, null, log);
+            if (!memories || memories.length === 0) {
+              return { content: [{ type: "text", text: "No relevant memories found for this query." }] };
+            }
+            const formatted = formatMemoriesForContext(memories, { currentTime: Date.now() });
+            return {
+              content: [{ type: "text", text: formatted }],
+              details: { hits: memories.length, query },
+            };
+          } catch (error) {
+            if (log?.warn) log.warn(`[Memory Plugin] Tool memory_search failed: ${error.message}`);
+            return { content: [{ type: "text", text: `Memory search failed: ${error.message}` }], isError: true };
+          }
+        },
+      });
 
-    const sessionId = resolveSessionId(ctx, event);
-    if (!sessionId) return;
+      api.registerTool({
+        name: "memory_store",
+        label: "Memory Store",
+        description: "Actively save important information, user preferences, or key decisions to long-term memory. Use this when the user shares something worth remembering for future conversations.",
+        parameters: {
+          type: "object",
+          properties: {
+            content: { type: "string", description: "The information to remember — be specific and include context" },
+            category: { type: "string", description: "Optional category tag (e.g. 'preference', 'fact', 'decision')" },
+          },
+          required: ["content"],
+        },
+        execute: async (_toolCallId, params) => {
+          const { content, category } = params;
+          if (log?.info) log.info(`[Memory Plugin] Tool memory_store: content="${truncate(content, 50)}", category=${category || 'none'}`);
+          try {
+            const messages = [
+              { role: "user", content: `[Memory Store${category ? ` | ${category}` : ""}] ${content}` },
+              { role: "assistant", content: `Noted and saved to memory: ${truncate(content, 100)}` },
+            ];
+            const result = await addMemory(messages, cfg, null, log);
+            return {
+              content: [{ type: "text", text: `Memory saved successfully: "${truncate(content, 80)}"` }],
+              details: { stored: true, category: category || null },
+            };
+          } catch (error) {
+            if (log?.warn) log.warn(`[Memory Plugin] Tool memory_store failed: ${error.message}`);
+            return { content: [{ type: "text", text: `Memory store failed: ${error.message}` }], isError: true };
+          }
+        },
+      });
 
-    if (log?.info) {
-      log.info(`[Memory Plugin] Session ending, flushing cache`);
+      if (log?.info) log.info(`[Memory Plugin] Registered 2 agent tools: memory_search, memory_store`);
     }
 
-    await flushSession(sessionId, cfg, ctx, log);
-  };
-
-  return {
-    hooks: {
-      "before_agent_start": recallHandler,
-      "agent_start": recallHandler,
-      "prompt_start": recallHandler,
-      "message_received": recallHandler,
-      "request_pre": recallHandler,
-      "before_recall": recallHandler,
-
-      "agent_end": storeHandler,
-      "prompt_end": storeHandler,
-      "request_post": storeHandler,
-      "message_sent": storeHandler,
-
-      "session_end": sessionEndHandler,
-    },
-  };
-}
+    if (log?.info) {
+      log.info(`[Memory Plugin] Registration complete: hooks=[before_prompt_build, agent_end, session_end], tools=${typeof api.registerTool === "function" ? 2 : 0}`);
+    }
+  },
+};
 
 /**
  * Build config from various sources
@@ -1311,7 +1272,7 @@ function buildConfig(config) {
   const configuredUserId = config?.userId || process.env.HUMAN_LIKE_MEM_USER_ID;
 
   return {
-    baseUrl: config?.baseUrl || process.env.HUMAN_LIKE_MEM_BASE_URL || "https://plugin.human-like.me",
+    baseUrl: config?.baseUrl || process.env.HUMAN_LIKE_MEM_BASE_URL || "https://human-like.me",
     apiKey: config?.apiKey || process.env.HUMAN_LIKE_MEM_API_KEY,
     configuredUserId: configuredUserId,
     userId: configuredUserId || "openclaw-user",