@humanlikememory/human-like-mem 0.3.11 → 0.3.13

package/README.md

@@ -1,70 +1,70 @@
-# Human-Like Memory Plugin for OpenClaw
-
-[![npm version](https://img.shields.io/npm/v/@humanlikememory/human-like-mem.svg)](https://www.npmjs.com/package/@humanlikememory/human-like-mem)
-
-Long-term memory plugin for OpenClaw with automatic memory recall and memory storage.
-
-## Install
-
-```bash
-npm install @humanlikememory/human-like-mem
-```
-
-## Enable In OpenClaw
-
-Edit `~/.openclaw/openclaw.json`:
-
-```json
-{
-  "plugins": {
-    "entries": {
-      "human-like-mem": {
-        "enabled": true
-      }
-    }
-  }
-}
-```
-
-## Required Environment Variables
-
-```bash
-export HUMAN_LIKE_MEM_API_KEY="mp_xxxxxx"
-```
-
-## Optional Environment Variables
-
-```bash
-export HUMAN_LIKE_MEM_BASE_URL="https://human-like.me"
-export HUMAN_LIKE_MEM_USER_ID="your-user-id"
-export HUMAN_LIKE_MEM_AGENT_ID="main"
-export HUMAN_LIKE_MEM_LIMIT_NUMBER="6"
-export HUMAN_LIKE_MEM_MIN_SCORE="0.1"
-export HUMAN_LIKE_MEM_MIN_TURNS="5"
-export HUMAN_LIKE_MEM_SESSION_TIMEOUT="300000"
-```
-
-## How It Works
-
-- Before response: the plugin retrieves relevant memories and injects them into context.
-- After response: the plugin caches the conversation and flushes memory by turn threshold or timeout.
-
-Default storage behavior:
-
-- `minTurnsToStore = 5`
-- `maxTurnsToStore = minTurnsToStore * 2`
-- `sessionTimeoutMs = 300000` (5 minutes)
-
-## Troubleshooting
-
-- If you see `HUMAN_LIKE_MEM_API_KEY not configured`, make sure the key is set in your runtime environment.
-- If you see request timeout logs, increase plugin `timeoutMs` (for example `30000`).
-- Check logs with:
-
-```bash
-openclaw logs --plain --limit 200
-```
-
-## License
-
-Apache-2.0
+# Human-Like Memory Plugin for OpenClaw
+
+[![npm version](https://img.shields.io/npm/v/@humanlikememory/human-like-mem.svg)](https://www.npmjs.com/package/@humanlikememory/human-like-mem)
+
+Long-term memory plugin for OpenClaw with automatic memory recall and memory storage.
+
+## Install
+
+```bash
+npm install @humanlikememory/human-like-mem
+```
+
+## Enable In OpenClaw
+
+Edit `~/.openclaw/openclaw.json`:
+
+```json
+{
+  "plugins": {
+    "entries": {
+      "human-like-mem": {
+        "enabled": true
+      }
+    }
+  }
+}
+```
+
+## Required Environment Variables
+
+```bash
+export HUMAN_LIKE_MEM_API_KEY="mp_xxxxxx"
+```
+
+## Optional Environment Variables
+
+```bash
+export HUMAN_LIKE_MEM_BASE_URL="https://plugin.human-like.me"
+export HUMAN_LIKE_MEM_USER_ID="your-user-id"
+export HUMAN_LIKE_MEM_AGENT_ID="main"
+export HUMAN_LIKE_MEM_LIMIT_NUMBER="6"
+export HUMAN_LIKE_MEM_MIN_SCORE="0.1"
+export HUMAN_LIKE_MEM_MIN_TURNS="5"
+export HUMAN_LIKE_MEM_SESSION_TIMEOUT="300000"
+```
+
+## How It Works
+
+- Before response: the plugin retrieves relevant memories and injects them into context.
+- After response: the plugin caches the conversation and flushes memory by turn threshold or timeout.
+
+Default storage behavior:
+
+- `minTurnsToStore = 5`
+- `maxTurnsToStore = minTurnsToStore * 2`
+- `sessionTimeoutMs = 300000` (5 minutes)
+
+## Troubleshooting
+
+- If you see `HUMAN_LIKE_MEM_API_KEY not configured`, make sure the key is set in your runtime environment.
+- If you see request timeout logs, increase plugin `timeoutMs` (for example `30000`).
+- Check logs with:
+
+```bash
+openclaw logs --plain --limit 200
+```
+
+## License
+
+Apache-2.0

package/README_ZH.md

@@ -1,70 +1,70 @@
-# Human-Like Memory Plugin for OpenClaw
-
-[![npm version](https://img.shields.io/npm/v/@humanlikememory/human-like-mem.svg)](https://www.npmjs.com/package/@humanlikememory/human-like-mem)
-
-OpenClaw 长期记忆插件，支持自动召回和自动存储对话记忆。
-
-## 安装
-
-```bash
-npm install @humanlikememory/human-like-mem
-```
-
-## 在 OpenClaw 中启用
-
-编辑 `~/.openclaw/openclaw.json`：
-
-```json
-{
-  "plugins": {
-    "entries": {
-      "human-like-mem": {
-        "enabled": true
-      }
-    }
-  }
-}
-```
-
-## 必填环境变量
-
-```bash
-export HUMAN_LIKE_MEM_API_KEY="mp_xxxxxx"
-```
-
-## 可选环境变量
-
-```bash
-export HUMAN_LIKE_MEM_BASE_URL="https://human-like.me"
-export HUMAN_LIKE_MEM_USER_ID="your-user-id"
-export HUMAN_LIKE_MEM_AGENT_ID="main"
-export HUMAN_LIKE_MEM_LIMIT_NUMBER="6"
-export HUMAN_LIKE_MEM_MIN_SCORE="0.1"
-export HUMAN_LIKE_MEM_MIN_TURNS="5"
-export HUMAN_LIKE_MEM_SESSION_TIMEOUT="300000"
-```
-
-## 工作机制
-
-- 回答前：插件检索相关记忆并注入上下文。
-- 回答后：插件缓存会话，在满足轮次阈值或超时后写入记忆。
-
-默认存储策略：
-
-- `minTurnsToStore = 5`
-- `maxTurnsToStore = minTurnsToStore * 2`
-- `sessionTimeoutMs = 300000`（5 分钟）
-
-## 常见问题
-
-- 如果日志出现 `HUMAN_LIKE_MEM_API_KEY not configured`，请确认运行时环境变量已生效。
-- 如果日志出现请求超时，请把插件 `timeoutMs` 调大（例如 `30000`）。
-- 查看日志：
-
-```bash
-openclaw logs --plain --limit 200
-```
-
-## 许可证
-
-Apache-2.0
+# Human-Like Memory Plugin for OpenClaw
+
+[![npm version](https://img.shields.io/npm/v/@humanlikememory/human-like-mem.svg)](https://www.npmjs.com/package/@humanlikememory/human-like-mem)
+
+OpenClaw 长期记忆插件，支持自动召回和自动存储对话记忆。
+
+## 安装
+
+```bash
+npm install @humanlikememory/human-like-mem
+```
+
+## 在 OpenClaw 中启用
+
+编辑 `~/.openclaw/openclaw.json`：
+
+```json
+{
+  "plugins": {
+    "entries": {
+      "human-like-mem": {
+        "enabled": true
+      }
+    }
+  }
+}
+```
+
+## 必填环境变量
+
+```bash
+export HUMAN_LIKE_MEM_API_KEY="mp_xxxxxx"
+```
+
+## 可选环境变量
+
+```bash
+export HUMAN_LIKE_MEM_BASE_URL="https://plugin.human-like.me"
+export HUMAN_LIKE_MEM_USER_ID="your-user-id"
+export HUMAN_LIKE_MEM_AGENT_ID="main"
+export HUMAN_LIKE_MEM_LIMIT_NUMBER="6"
+export HUMAN_LIKE_MEM_MIN_SCORE="0.1"
+export HUMAN_LIKE_MEM_MIN_TURNS="5"
+export HUMAN_LIKE_MEM_SESSION_TIMEOUT="300000"
+```
+
+## 工作机制
+
+- 回答前：插件检索相关记忆并注入上下文。
+- 回答后：插件缓存会话，在满足轮次阈值或超时后写入记忆。
+
+默认存储策略：
+
+- `minTurnsToStore = 5`
+- `maxTurnsToStore = minTurnsToStore * 2`
+- `sessionTimeoutMs = 300000`（5 分钟）
+
+## 常见问题
+
+- 如果日志出现 `HUMAN_LIKE_MEM_API_KEY not configured`，请确认运行时环境变量已生效。
+- 如果日志出现请求超时，请把插件 `timeoutMs` 调大（例如 `30000`）。
+- 查看日志：
+
+```bash
+openclaw logs --plain --limit 200
+```
+
+## 许可证
+
+Apache-2.0

package/index.js

@@ -8,6 +8,7 @@
 
 const PLUGIN_VERSION = "0.3.4";
 const USER_QUERY_MARKER = "--- User Query ---";
+const CACHE_DEDUP_WINDOW_MS = 4000;
 
 /**
  * Session cache for tracking conversation history
@@ -59,6 +60,127 @@ function extractText(content) {
   return "";
 }
 
+function isToolCallBlock(block) {
+  if (!block || typeof block !== "object") return false;
+  const type = String(block.type || "").trim().toLowerCase();
+  return type === "toolcall" || type === "tool_call";
+}
+
+function normalizeToolCallBlock(block) {
+  if (!isToolCallBlock(block)) return null;
+
+  const name =
+    block.function?.name ||
+    block.toolName ||
+    block.name ||
+    "unknown";
+  const args =
+    block.function?.arguments ??
+    block.arguments ??
+    block.args ??
+    block.input ??
+    {};
+  const callId =
+    block.id ||
+    block.callId ||
+    block.toolCallId ||
+    block.tool_call_id ||
+    null;
+
+  return {
+    id: callId,
+    name,
+    arguments: args,
+    function: {
+      name,
+      arguments: args,
+    },
+  };
+}
+
+function extractToolCallsFromContent(content) {
+  if (!Array.isArray(content)) return [];
+
+  return content
+    .map((block) => normalizeToolCallBlock(block))
+    .filter(Boolean);
+}
+
+function getMessageToolCalls(msg) {
+  if (!msg || typeof msg !== "object") return [];
+  if (Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0) {
+    return msg.tool_calls;
+  }
+  return extractToolCallsFromContent(msg.content);
+}
+
+function getToolResultCallId(msg) {
+  if (!msg || typeof msg !== "object") return null;
+  return (
+    msg.tool_call_id ||
+    msg.toolCallId ||
+    msg.call_id ||
+    msg.callId ||
+    null
+  );
+}
+
+function getToolResultName(msg) {
+  if (!msg || typeof msg !== "object") return undefined;
+  return msg.name || msg.toolName || msg.tool_name || undefined;
+}
+
+function normalizeCacheRole(role) {
+  if (role === "toolResult") return "tool";
+  return role;
+}
+
+function isAssistantLikeRole(role) {
+  return role === "assistant" || role === "tool" || role === "toolResult";
+}
+
+function buildCacheMessageFromTranscript(msg) {
+  if (!msg || msg.role === "system") return null;
+
+  const normalizedRole = normalizeCacheRole(msg.role);
+  let content = "";
+  let rawSource = msg.content;
+  let messageId = "";
+
+  if (msg.role === "user") {
+    content = normalizeUserMessageContent(msg.content);
+    rawSource = stripPrependedPrompt(msg.content);
+    messageId = extractRelayMessageId(rawSource || "");
+  } else if (msg.role === "assistant") {
+    content = normalizeAssistantMessageContent(msg.content);
+    rawSource = extractText(msg.content);
+  } else if (normalizedRole === "tool") {
+    content = extractText(msg.content);
+    rawSource = content;
+  } else {
+    return null;
+  }
+
+  const toolCalls = getMessageToolCalls(msg);
+  const toolCallId = getToolResultCallId(msg);
+  const toolName = getToolResultName(msg);
+  const hasToolContext =
+    (normalizedRole === "assistant" && toolCalls.length > 0) ||
+    (normalizedRole === "tool" && (!!toolCallId || !!toolName));
+
+  if (!content && !hasToolContext) return null;
+
+  return {
+    role: normalizedRole,
+    content: content || "",
+    rawContent: rawSource || undefined,
+    messageId: messageId || undefined,
+    tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+    tool_call_id: toolCallId || undefined,
+    name: toolName,
+  };
+}
+
 /**
  * Strip prepended prompt markers from message content
  */
@@ -123,6 +245,65 @@ function isMetadataOnlyText(text) {
   return false;
 }
 
+/**
+ * Remove injected relay metadata blocks/lines from user content.
+ */
+function stripInjectedMetadata(text) {
+  if (!text || typeof text !== "string") return "";
+
+  let result = text.replace(/\r\n/g, "\n");
+
+  // Remove labeled untrusted metadata JSON blocks.
+  // Examples:
+  // Conversation info (untrusted metadata): ```json ... ```
+  // Sender (untrusted metadata): ```json ... ```
+  result = result.replace(
+    /(^|\n)[^\n]*\(untrusted metadata(?:,\s*for context)?\)\s*:\s*```json[\s\S]*?```(?=\n|$)/gi,
+    "\n"
+  );
+
+  // Remove transport/system hint lines that are not user utterances.
+  result = result.replace(/^\[System:[^\n]*\]\s*$/gim, "");
+  result = result.replace(/^\[message_id:\s*[^\]]+\]\s*$/gim, "");
+
+  // Collapse extra blank lines.
+  result = result.replace(/\n{3,}/g, "\n\n").trim();
+  return result;
+}
+
+/**
+ * Keep the latest meaningful line from cleaned metadata-injected payload.
+ */
+function extractLatestUtteranceFromCleanText(text) {
+  if (!text || typeof text !== "string") return "";
+  const lines = text
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .filter((line) => !isMetadataOnlyText(line));
+  if (lines.length === 0) return "";
+  return lines[lines.length - 1];
+}
+
+function escapeRegex(text) {
+  return String(text).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Prefix utterance with parsed sender name when available.
+ * This preserves who said it in multi-user group contexts.
+ */
+function attachSenderPrefix(utterance, senderName) {
+  const content = String(utterance || "").trim();
+  if (!content) return "";
+  const sender = String(senderName || "").trim();
+  if (!sender) return content;
+
+  const senderRegex = new RegExp(`^${escapeRegex(sender)}\\s*[:：]`);
+  if (senderRegex.test(content)) return content;
+  return `${sender}: ${content}`;
+}
+
 /**
  * Normalize user message text before caching/storing.
  * For channel-formatted payloads (e.g. Feishu), keep only the actual user utterance
@@ -135,6 +316,17 @@ function normalizeUserMessageContent(content) {
   const normalized = String(text).replace(/\r\n/g, "\n").trim();
   if (!normalized) return "";
 
+  const parsedIdentity = parseIdentityFromUntrustedMetadata(normalized);
+
+  // New relay payload format: strip injected metadata blocks first.
+  const strippedMetadata = stripInjectedMetadata(normalized);
+  if (strippedMetadata && strippedMetadata !== normalized) {
+    const latestUtterance = extractLatestUtteranceFromCleanText(strippedMetadata);
+    if (latestUtterance && !isMetadataOnlyText(latestUtterance)) {
+      return attachSenderPrefix(latestUtterance, parsedIdentity?.userName);
+    }
+  }
+
   // Feishu: preserve the final traceable tail block (contains platform user id/message_id).
   const feishuTailBlock = extractFeishuTailBlock(normalized);
   if (feishuTailBlock && !isMetadataOnlyText(feishuTailBlock)) {
@@ -168,7 +360,9 @@ function normalizeUserMessageContent(content) {
     if (!isMetadataOnlyText(candidate)) return candidate;
   }
 
-  return isMetadataOnlyText(normalized) ? "" : normalized;
+  return isMetadataOnlyText(normalized)
+    ? ""
+    : attachSenderPrefix(normalized, parsedIdentity?.userName);
 }
 
 /**
@@ -183,6 +377,125 @@ function normalizeAssistantMessageContent(content) {
   return normalized;
 }
 
+/**
+ * Parse JSON objects from markdown code fences after a specific label.
+ * Example:
+ * Sender (untrusted metadata):
+ * ```json
+ * { "id": "123" }
+ * ```
+ */
+function parseJsonFencesAfterLabel(text, labelPattern) {
+  if (!text || typeof text !== "string") return [];
+
+  const results = [];
+  const regex = new RegExp(`${labelPattern}\\s*:\\s*\`\`\`json\\s*([\\s\\S]*?)\\s*\`\`\``, "gi");
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    if (!match[1]) continue;
+    try {
+      const parsed = JSON.parse(match[1]);
+      if (parsed && typeof parsed === "object") {
+        results.push(parsed);
+      }
+    } catch (_) {
+      // Ignore malformed JSON blocks and continue matching others.
+    }
+  }
+  return results;
+}
+
+/**
+ * Normalize potential user id values into non-empty strings.
+ */
+function normalizeParsedUserId(value) {
+  if (value === undefined || value === null) return "";
+  const normalized = String(value).trim();
+  return normalized || "";
+}
+
+/**
+ * Extract user id from a display label like:
+ * "用户250389 (ou_xxx)" / "name (123456789)".
+ */
+function extractUserIdFromLabel(label) {
+  const text = normalizeParsedUserId(label);
+  if (!text) return "";
+  const match = text.match(/\(\s*((?:ou|on|u)_[A-Za-z0-9]+|\d{6,})\s*\)$/i);
+  return match?.[1] ? match[1] : "";
+}
+
+/**
+ * Extract transport message id from current relay payload.
+ */
+function extractRelayMessageId(text) {
+  if (!text || typeof text !== "string") return "";
+
+  const conversationMetaList = parseJsonFencesAfterLabel(
+    text,
+    "Conversation info \\(untrusted metadata\\)"
+  );
+  for (let i = conversationMetaList.length - 1; i >= 0; i--) {
+    const conversationMeta = conversationMetaList[i];
+    const messageId =
+      normalizeParsedUserId(conversationMeta?.message_id) ||
+      normalizeParsedUserId(conversationMeta?.messageId);
+    if (messageId) return messageId;
+  }
+
+  const messageIdMatch = text.match(/\[message_id:\s*([^\]\n]+)\]/i);
+  if (messageIdMatch?.[1]) return messageIdMatch[1].trim();
+
+  return "";
+}
+
+/**
+ * Parse identity from new "untrusted metadata" JSON blocks.
+ * Priority:
+ * 1) Sender (untrusted metadata).id
+ * 2) Conversation info (untrusted metadata).sender_id
+ */
+function parseIdentityFromUntrustedMetadata(text) {
+  if (!text || typeof text !== "string") return null;
+
+  const senderMetaList = parseJsonFencesAfterLabel(text, "Sender \\(untrusted metadata\\)");
+  for (let i = senderMetaList.length - 1; i >= 0; i--) {
+    const senderMeta = senderMetaList[i];
+    const userId =
+      normalizeParsedUserId(senderMeta?.id) ||
+      extractUserIdFromLabel(senderMeta?.label);
+    if (userId) {
+      return {
+        platform: null,
+        userId,
+        userName: senderMeta?.name || senderMeta?.username || senderMeta?.label || null,
+        source: "sender-untrusted-metadata-json",
+      };
+    }
+  }
+
+  const conversationMetaList = parseJsonFencesAfterLabel(
+    text,
+    "Conversation info \\(untrusted metadata\\)"
+  );
+  for (let i = conversationMetaList.length - 1; i >= 0; i--) {
+    const conversationMeta = conversationMetaList[i];
+    const userId =
+      normalizeParsedUserId(conversationMeta?.sender_id) ||
+      normalizeParsedUserId(conversationMeta?.senderId);
+    if (userId) {
+      return {
+        platform: null,
+        userId,
+        userName: conversationMeta?.sender || null,
+        source: "conversation-untrusted-metadata-json",
+      };
+    }
+  }
+
+  return null;
+}
+
 /**
  * Parse platform identity hints from channel-formatted message text.
  * Returns null when no platform-specific id can be extracted.
@@ -190,6 +503,14 @@ function normalizeAssistantMessageContent(content) {
 function parsePlatformIdentity(text) {
   if (!text || typeof text !== "string") return null;
 
+  // New Discord format first:
+  // Sender (untrusted metadata): ```json { "id": "116..." } ```
+  // Conversation info (untrusted metadata): ```json { "sender_id": "116..." } ```
+  const metadataIdentity = parseIdentityFromUntrustedMetadata(text);
+  if (metadataIdentity?.userId) {
+    return metadataIdentity;
+  }
+
   // Discord example:
   // [from: huang yongqing (1470374017541079042)]
   const discordFrom = text.match(/\[from:\s*([^\(\]\n]+?)\s*\((\d{6,})\)\]/i);
@@ -224,11 +545,32 @@ function parseAllPlatformUserIds(text) {
   if (!text || typeof text !== "string") return [];
 
   const ids = [];
+  let match;
+
+  // New format: "Sender (untrusted metadata)" JSON blocks.
+  const senderMetaList = parseJsonFencesAfterLabel(text, "Sender \\(untrusted metadata\\)");
+  for (const senderMeta of senderMetaList) {
+    const parsedId =
+      normalizeParsedUserId(senderMeta?.id) ||
+      extractUserIdFromLabel(senderMeta?.label);
+    if (parsedId) ids.push(parsedId);
+  }
+
+  // New format: "Conversation info (untrusted metadata)" JSON blocks.
+  const conversationMetaList = parseJsonFencesAfterLabel(
+    text,
+    "Conversation info \\(untrusted metadata\\)"
+  );
+  for (const conversationMeta of conversationMetaList) {
+    const parsedId =
+      normalizeParsedUserId(conversationMeta?.sender_id) ||
+      normalizeParsedUserId(conversationMeta?.senderId);
+    if (parsedId) ids.push(parsedId);
+  }
 
   // Discord example:
   // [from: huang yongqing (1470374017541079042)]
   const discordRegex = /\[from:\s*[^\(\]\n]+?\s*\((\d{6,})\)\]/gi;
-  let match;
   while ((match = discordRegex.exec(text)) !== null) {
     if (match[1]) ids.push(match[1]);
   }
@@ -266,6 +608,90 @@ function collectUniqueUserIdsFromMessages(messages, fallbackUserId) {
   return Array.from(unique);
 }
 
+function extractUserNameFromLabel(label) {
+  const text = normalizeParsedUserId(label);
+  if (!text) return "";
+  const match = text.match(
+    /^(.*?)\s*\(\s*(?:(?:ou|on|u)_[A-Za-z0-9]+|\d{6,})\s*\)\s*$/i
+  );
+  return match?.[1] ? match[1].trim() : text;
+}
+
+/**
+ * Parse name-id pairs from supported relay payload formats.
+ */
+function parseNameIdPairsFromText(text) {
+  if (!text || typeof text !== "string") return [];
+  const pairs = [];
+
+  // New format: Sender (untrusted metadata)
+  const senderMetaList = parseJsonFencesAfterLabel(text, "Sender \\(untrusted metadata\\)");
+  for (const senderMeta of senderMetaList) {
+    const id =
+      normalizeParsedUserId(senderMeta?.id) ||
+      extractUserIdFromLabel(senderMeta?.label);
+    const name =
+      normalizeParsedUserId(senderMeta?.name) ||
+      normalizeParsedUserId(senderMeta?.username) ||
+      extractUserNameFromLabel(senderMeta?.label);
+    if (name && id) pairs.push([name, id]);
+  }
+
+  // New format: Conversation info (untrusted metadata)
+  const conversationMetaList = parseJsonFencesAfterLabel(
+    text,
+    "Conversation info \\(untrusted metadata\\)"
+  );
+  for (const conversationMeta of conversationMetaList) {
+    const id =
+      normalizeParsedUserId(conversationMeta?.sender_id) ||
+      normalizeParsedUserId(conversationMeta?.senderId);
+    const name = normalizeParsedUserId(conversationMeta?.sender);
+    if (name && id) pairs.push([name, id]);
+  }
+
+  // Old Discord: [from: name (id)]
+  const discordRegex = /\[from:\s*([^\(\]\n]+?)\s*\((\d{6,})\)\]/gi;
+  let match;
+  while ((match = discordRegex.exec(text)) !== null) {
+    const name = normalizeParsedUserId(match[1]);
+    const id = normalizeParsedUserId(match[2]);
+    if (name && id) pairs.push([name, id]);
+  }
+
+  // Old Feishu: [Feishu ...:ou_xxx ...] name:
+  const feishuRegex = /\[Feishu[^\]]*:((?:ou|on|u)_[A-Za-z0-9]+)[^\]]*\]\s*([^:\n]+):/gi;
+  while ((match = feishuRegex.exec(text)) !== null) {
+    const id = normalizeParsedUserId(match[1]);
+    const name = normalizeParsedUserId(match[2]);
+    if (name && id) pairs.push([name, id]);
+  }
+
+  return pairs;
+}
+
+/**
+ * Collect distinct name->id mapping from all messages.
+ */
+function collectNameIdMapFromMessages(messages) {
+  const map = {};
+
+  if (!Array.isArray(messages)) return map;
+
+  for (const msg of messages) {
+    if (!msg) continue;
+    const sourceText = msg.rawContent !== undefined ? msg.rawContent : msg.content;
+    const text = typeof sourceText === "string" ? sourceText : extractText(sourceText);
+    const pairs = parseNameIdPairsFromText(text);
+    for (const [name, id] of pairs) {
+      if (!name || !id) continue;
+      map[name] = id;
+    }
+  }
+
+  return map;
+}
+
 /**
  * Get latest user message text from cached messages.
  */
@@ -284,7 +710,7 @@ function getLatestUserMessageText(messages) {
  * Resolve request identity with fallback:
  * platform user id -> configured user id -> "openclaw-user"
  */
-function resolveRequestIdentity(promptText, cfg, ctx) {
+function resolveRequestIdentity(promptText, cfg) {
   const parsed = parsePlatformIdentity(promptText);
   if (parsed?.userId) {
     return {
@@ -304,15 +730,6 @@ function resolveRequestIdentity(promptText, cfg, ctx) {
     };
   }
 
-  if (ctx?.userId) {
-    return {
-      userId: ctx.userId,
-      userName: null,
-      platform: null,
-      source: "ctx-user-id",
-    };
-  }
-
   return {
     userId: "openclaw-user",
     userName: null,
@@ -507,7 +924,7 @@ async function retrieveMemory(prompt, cfg, ctx, log) {
   if (log?.info) {
     log.info(`[Memory Plugin] Recall request URL: ${url}`);
   }
-  const identity = resolveRequestIdentity(prompt, cfg, ctx);
+  const identity = resolveRequestIdentity(prompt, cfg);
   const userId = sanitizeUserId(identity.userId);
   const payload = {
     query: prompt,
@@ -554,7 +971,7 @@ async function retrieveMemory(prompt, cfg, ctx, log) {
 /**
  * Add memories to the API
  */
-async function addMemory(messages, cfg, ctx, log) {
+async function addMemory(messages, cfg, ctx, log, explicitSessionId) {
   const baseUrl = cfg.baseUrl || process.env.HUMAN_LIKE_MEM_BASE_URL;
   const apiKey = cfg.apiKey || process.env.HUMAN_LIKE_MEM_API_KEY;
 
@@ -564,9 +981,9 @@ async function addMemory(messages, cfg, ctx, log) {
   if (log?.info) {
     log.info(`[Memory Plugin] Add-memory request URL: ${url}`);
   }
-  const sessionId = resolveSessionId(ctx, null) || `session-${Date.now()}`;
+  const sessionId = explicitSessionId || resolveSessionId(ctx, null) || `session-${Date.now()}`;
   const latestUserText = getLatestUserMessageText(messages);
-  const identity = resolveRequestIdentity(latestUserText, cfg, ctx);
+  const identity = resolveRequestIdentity(latestUserText, cfg);
   const userId = sanitizeUserId(identity.userId);
   const metadataUserIds = (() => {
     const parsed = collectUniqueUserIdsFromMessages(messages, null)
@@ -577,6 +994,13 @@ async function addMemory(messages, cfg, ctx, log) {
     }
     return [userId];
   })();
+  const nameIdMap = (() => {
+    const parsed = collectNameIdMapFromMessages(messages);
+    if (identity?.userName && userId && !parsed[identity.userName]) {
+      parsed[identity.userName] = userId;
+    }
+    return parsed;
+  })();
   const agentId = cfg.agentId || ctx?.agentId || "main";
 
   const payload = {
@@ -594,6 +1018,7 @@ async function addMemory(messages, cfg, ctx, log) {
         metadata: JSON.stringify({
           user_ids: metadataUserIds,
           agent_ids: [agentId],
+          name_id_map: nameIdMap,
           session_id: sessionId,
           scenario: cfg.scenario || "openclaw-plugin",
         }),
@@ -603,7 +1028,7 @@ async function addMemory(messages, cfg, ctx, log) {
 
   if (log?.debug) {
     log.debug(
-      `[Memory Plugin] add/message payload: user_id=${userId}, agent_id=${agentId}, conversation_id=${sessionId}, metadata.user_ids=${JSON.stringify(metadataUserIds)}, metadata.agent_ids=${JSON.stringify([agentId])}`
+      `[Memory Plugin] add/message payload: user_id=${userId}, agent_id=${agentId}, conversation_id=${sessionId}, metadata.user_ids=${JSON.stringify(metadataUserIds)}, metadata.agent_ids=${JSON.stringify([agentId])}, metadata.name_id_map=${JSON.stringify(nameIdMap)}`
     );
   }
 
@@ -753,8 +1178,8 @@ function formatMemoriesForContext(memories, options = {}) {
  * @param {number} maxTurns - Maximum number of turns to extract
  * @returns {Array} Recent messages
  */
-function pickRecentMessages(messages, maxTurns = 10) {
-  if (!messages || messages.length === 0) return [];
+function pickRecentMessages(messages, maxTurns = 10) {
+  if (!messages || messages.length === 0) return [];
 
   const result = [];
   let turnCount = 0;
@@ -769,7 +1194,7 @@ function pickRecentMessages(messages, maxTurns = 10) {
     if (role === "system") continue;
 
     // Count a turn when we see a user message after an assistant message
-    if (role === "user" && lastRole === "assistant") {
+    if (role === "user" && isAssistantLikeRole(lastRole)) {
       turnCount++;
     }
 
@@ -795,9 +1220,230 @@ function pickRecentMessages(messages, maxTurns = 10) {
     lastRole = role;
   }
 
-  return result;
+  return result;
+}
+
+function buildV2ConversationMessage(msg) {
+  if (!msg) return null;
+
+  const role = normalizeCacheRole(msg.role);
+  if (role === "system") return null;
+  if (role !== "user" && role !== "assistant" && role !== "tool") return null;
+
+  const rawSource = msg.rawContent !== undefined ? msg.rawContent : msg.content;
+  const rawContent = typeof rawSource === "string" ? rawSource : extractText(rawSource);
+  const content =
+    typeof msg.content === "string"
+      ? msg.content
+      : extractText(msg.content);
+  const toolCalls = role === "assistant" ? getMessageToolCalls(msg) : [];
+  const toolCallId = role === "tool" ? getToolResultCallId(msg) : null;
+  const toolName = role === "tool" ? getToolResultName(msg) : undefined;
+  const hasToolContext =
+    (role === "assistant" && toolCalls.length > 0) ||
+    (role === "tool" && (!!toolCallId || !!toolName));
+
+  if (!content && !hasToolContext) return null;
+
+  const result = {
+    role,
+    content: content || "",
+    rawContent: rawContent || undefined,
+  };
+
+  if (toolCalls.length > 0) result.tool_calls = toolCalls;
+  if (toolCallId) result.tool_call_id = toolCallId;
+  if (toolName) result.name = toolName;
+
+  return result;
+}
+
+function pickRecentContextMessagesV2(messages, maxTurns = 10) {
+  if (!messages || messages.length === 0) return [];
+
+  const result = [];
+  let turnCount = 0;
+  let lastRole = null;
+
+  for (let i = messages.length - 1; i >= 0 && turnCount < maxTurns; i--) {
+    const msg = messages[i];
+    const role = normalizeCacheRole(msg?.role);
+
+    if (role === "system") continue;
+
+    if (role === "user" && isAssistantLikeRole(lastRole)) {
+      turnCount++;
+    }
+
+    if (turnCount >= maxTurns) break;
+
+    const contextMessage = buildV2ConversationMessage(msg);
+    if (contextMessage) {
+      result.unshift(contextMessage);
+    }
+
+    lastRole = role;
+  }
+
+  return result;
+}
+
+function stripToolMessagesForV1(messages) {
+  if (!Array.isArray(messages)) return [];
+
+  return messages
+    .filter((msg) => msg && (msg.role === "user" || msg.role === "assistant"))
+    .filter((msg) => String(msg.content || "").trim())
+    .map((msg) => ({
+      role: msg.role,
+      content: msg.content,
+      rawContent: msg.rawContent,
+    }));
+}
+
+/**
+ * Extract tool calls from cached messages for the v2 context protocol.
+ * @param {Array} messages - All cached messages
+ * @returns {Array} Tool call records
+ */
+function extractToolCalls(messages) {
+  if (!messages || messages.length === 0) return [];
+
+  const calls = [];
+  for (const msg of messages) {
+    if (msg.role === "assistant") {
+      const toolCalls = getMessageToolCalls(msg);
+      for (const tc of toolCalls) {
+        calls.push({
+          tool_name: tc.function?.name || tc.name || "unknown",
+          arguments: tc.function?.arguments || tc.arguments || {},
+          call_id: tc.id || null,
+          result: null,
+          success: null,
+          duration_ms: null,
+        });
+      }
+    }
+
+    if (msg.role === "tool") {
+      const toolCallId = getToolResultCallId(msg);
+      const toolName = getToolResultName(msg);
+      const match = calls.find((call) =>
+        (toolCallId && call.call_id === toolCallId) ||
+        (!toolCallId && toolName && call.tool_name === toolName && call.result == null)
+      );
+      if (match) {
+        const resultText = extractText(msg.rawContent !== undefined ? msg.rawContent : msg.content);
+        match.result = truncate(resultText, 2000);
+        match.success = !isErrorResult(resultText);
+      }
+    }
+  }
+
+  return calls;
 }
 
+/**
+ * Check if text looks like an error result
+ * @param {string} text - Result text
+ * @returns {boolean}
+ */
+function isErrorResult(text) {
+  if (!text) return false;
+  const lower = String(text).toLowerCase();
+  return lower.includes("error") || lower.includes("exception") ||
+    lower.includes("failed") || lower.includes("traceback") ||
+    lower.includes("enoent") || lower.includes("permission denied");
+}
+
+/**
+ * Collect context blocks from messages (v2 protocol)
+ * @param {Array} messages - All cached messages
+ * @param {Object} cfg - Configuration
+ * @returns {Array} Context blocks
+ */
+function collectContextBlocks(messages, cfg) {
+  const blocks = [];
+
+  const conversationMsgs =
+    cfg.captureToolCalls === false
+      ? pickRecentMessages(messages, cfg.maxTurnsToStore || 10)
+      : pickRecentContextMessagesV2(messages, cfg.maxTurnsToStore || 10);
+  if (conversationMsgs.length > 0) {
+    blocks.push({
+      type: "conversation",
+      data: { messages: conversationMsgs },
+    });
+  }
+
+  return blocks;
+}
+
+/**
+ * Add context via v2 protocol
+ */
+async function addContextV2(contextBlocks, cfg, ctx, log, sessionId) {
+  const baseUrl = cfg.baseUrl || process.env.HUMAN_LIKE_MEM_BASE_URL;
+  const apiKey = cfg.apiKey || process.env.HUMAN_LIKE_MEM_API_KEY;
+
+  if (!apiKey) return;
+
+  const url = `${baseUrl}/api/plugin/v2/add/context`;
+  const latestUserText = getLatestUserMessageText(
+    contextBlocks.find((block) => block.type === "conversation")?.data?.messages || []
+  );
+  const identity = resolveRequestIdentity(latestUserText, cfg);
+  const userId = sanitizeUserId(identity.userId);
+  const agentId = cfg.agentId || ctx?.agentId || "main";
+
+  const payload = {
+    user_id: userId,
+    conversation_id: sessionId,
+    agent_id: agentId,
+    tags: cfg.tags || ["openclaw"],
+    async_mode: true,
+    protocol_version: "2.0",
+    context_blocks: contextBlocks,
+  };
+
+  if (log?.debug) {
+    log.debug(
+      `[Memory Plugin] v2 add/context: blocks=${contextBlocks.length}, types=${contextBlocks.map((block) => block.type).join(",")}`
+    );
+  }
+
+  try {
+    const result = await httpRequest(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey,
+        "x-request-id": ctx?.requestId || `openclaw-${Date.now()}`,
+        "x-plugin-version": PLUGIN_VERSION,
+        "x-client-type": "plugin",
+      },
+      body: JSON.stringify(payload),
+    }, cfg, log);
+
+    const memoryCount = result?.memories_count || 0;
+    if (log?.info) {
+      log.info(
+        `[Memory Plugin] v2 add/context success: ${memoryCount} memories from ${result?.blocks_processed || 0} blocks`
+      );
+    }
+    return result;
+  } catch (error) {
+    if (log?.warn) {
+      log.warn(`[Memory Plugin] v2 add/context failed, falling back to v1: ${error.message}`);
+    }
+    const conversationBlock = contextBlocks.find((block) => block.type === "conversation");
+    if (conversationBlock) {
+      return await addMemory(stripToolMessagesForV1(conversationBlock.data.messages), cfg, ctx, log, sessionId);
+    }
+    throw error;
+  }
+}
+
 /**
  * Check if conversation has enough turns to be worth storing
  * @param {Array} messages - Messages to check
@@ -817,7 +1463,7 @@ function isConversationWorthStoring(messages, cfg) {
     if (msg.role === "system") continue;
 
     if (msg.role === "user") {
-      if (lastRole === "assistant") {
+      if (isAssistantLikeRole(lastRole)) {
         turns++;
       }
     }
@@ -852,13 +1498,39 @@ function getSessionCache(sessionId) {
  */
 function addToSessionCache(sessionId, message) {
   const cache = getSessionCache(sessionId);
-  cache.messages.push(message);
+  const now = Date.now();
+  const incoming = {
+    ...message,
+    cachedAt: now,
+  };
+
+  const prev = cache.messages.length > 0 ? cache.messages[cache.messages.length - 1] : null;
+  if (prev) {
+    const sameRole = prev.role === incoming.role;
+    const sameMessageId =
+      incoming.messageId &&
+      prev.messageId &&
+      String(incoming.messageId) === String(prev.messageId);
+    const sameContent =
+      sameRole &&
+      String(prev.content || "") === String(incoming.content || "") &&
+      String(prev.rawContent || "") === String(incoming.rawContent || "");
+    const withinWindow = now - (prev.cachedAt || 0) <= CACHE_DEDUP_WINDOW_MS;
+
+    // Dedup duplicate hook triggers for the same relay message.
+    if ((sameRole && sameMessageId) || (sameContent && withinWindow)) {
+      cache.lastActivity = now;
+      return cache;
+    }
+  }
+
+  cache.messages.push(incoming);
   cache.lastActivity = Date.now();
 
   // Count turns (user message after assistant = new turn)
-  if (message.role === "user" && cache.messages.length > 1) {
+  if (incoming.role === "user" && cache.messages.length > 1) {
     const prevMsg = cache.messages[cache.messages.length - 2];
-    if (prevMsg && prevMsg.role === "assistant") {
+    if (prevMsg && isAssistantLikeRole(prevMsg.role)) {
       cache.turnCount++;
     }
   }
@@ -970,6 +1642,15 @@ async function flushSession(sessionId, cfg, ctx, log) {
     if (log?.info) {
       log.info(`[Memory Plugin] Flushing session ${sessionId}: ${messagesToSave.length} messages, ${cache.turnCount} turns`);
     }
+
+    if (cfg.useV2Protocol !== false) {
+      const contextBlocks = collectContextBlocks(cache.messages, cfg);
+      if (contextBlocks.length > 0) {
+        await addContextV2(contextBlocks, cfg, ctx, log, sessionId);
+        return;
+      }
+    }
+
     await addMemory(messagesToSave, cfg, ctx, log, sessionId);
   } catch (error) {
     if (log?.warn) {
@@ -1021,8 +1702,14 @@ function registerPlugin(api) {
     const sessionId = resolveSessionId(ctx, event) || `session-${Date.now()}`;
     const userContent = normalizeUserMessageContent(prompt);
     const rawUserContent = stripPrependedPrompt(prompt);
+    const messageId = extractRelayMessageId(rawUserContent || prompt);
     if (userContent) {
-      addToSessionCache(sessionId, { role: "user", content: userContent, rawContent: rawUserContent });
+      addToSessionCache(sessionId, {
+        role: "user",
+        content: userContent,
+        rawContent: rawUserContent,
+        messageId: messageId || undefined,
+      });
     }
 
     try {
@@ -1070,22 +1757,28 @@ function registerPlugin(api) {
       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) {
+    if (event?.messages?.length) {
+      const pending = [];
       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 role = event.messages[i].role;
+        if (role === "system") continue;
+        if (role === "user") break;
+
+        const cacheMessage = buildCacheMessageFromTranscript(event.messages[i]);
+        if (cacheMessage) pending.unshift(cacheMessage);
+      }
+      for (const cacheMessage of pending) {
+        addToSessionCache(sessionId, cacheMessage);
+      }
+    } else {
+      const assistantContent = event?.response || event?.result;
+      if (assistantContent) {
+        const cacheMessage = buildCacheMessageFromTranscript({
+          role: "assistant",
+          content: assistantContent,
+        });
+        if (cacheMessage) {
+          addToSessionCache(sessionId, cacheMessage);
         }
       }
     }
@@ -1153,8 +1846,14 @@ function createHooksPlugin(config) {
     const sessionId = resolveSessionId(ctx, event) || `session-${Date.now()}`;
     const userContent = normalizeUserMessageContent(prompt);
     const rawUserContent = stripPrependedPrompt(prompt);
+    const messageId = extractRelayMessageId(rawUserContent || prompt);
     if (userContent) {
-      addToSessionCache(sessionId, { role: "user", content: userContent, rawContent: rawUserContent });
+      addToSessionCache(sessionId, {
+        role: "user",
+        content: userContent,
+        rawContent: rawUserContent,
+        messageId: messageId || undefined,
+      });
     }
 
     try {
@@ -1219,37 +1918,37 @@ function createHooksPlugin(config) {
       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 cacheMessage = buildCacheMessageFromTranscript(msg);
+          if (cacheMessage) {
+            addToSessionCache(sessionId, cacheMessage);
           }
         }
       } else {
-        // Only add last assistant message
+        // Add trailing assistant/tool messages from the latest completion.
+        const pending = [];
         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 msg = event.messages[i];
+          if (msg.role === "system") continue;
+          if (msg.role === "user") break;
+
+          const cacheMessage = buildCacheMessageFromTranscript(msg);
+          if (cacheMessage) {
+            pending.unshift(cacheMessage);
           }
         }
+        for (const cacheMessage of pending) {
+          addToSessionCache(sessionId, cacheMessage);
+        }
       }
     } 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 });
+        const cacheMessage = buildCacheMessageFromTranscript({
+          role: "assistant",
+          content: assistantContent,
+        });
+        if (cacheMessage) {
+          addToSessionCache(sessionId, cacheMessage);
         }
       }
     }

package/openclaw.plugin.json

@@ -3,7 +3,7 @@
   "id": "human-like-mem",
   "name": "Human-Like Memory Plugin",
   "description": "Long-term memory plugin with automatic recall and storage.",
-  "version": "0.3.11",
+  "version": "0.3.13",
   "kind": "lifecycle",
   "main": "./index.js",
   "author": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@humanlikememory/human-like-mem",
-  "version": "0.3.11",
+  "version": "0.3.13",
   "description": "Long-term memory plugin for OpenClaw - AI Social Memory Integration",
   "main": "index.js",
   "type": "module",
@@ -50,7 +50,7 @@
     "jest": "^29.7.0",
     "prettier": "^3.2.0"
   },
-  "publishConfig": {
-    "access": "public"
-  }
-}
+  "publishConfig": {
+    "access": "public"
+  }
+}