@memtensor/memos-cloud-openclaw-plugin 0.1.10-beta.4 → 0.1.11-beta.0

package/index.js

@@ -5,6 +5,8 @@ import {
   extractResultData,
   extractText,
   formatRecallHookResult,
+  isAgentAllowed,
+  resolveAgentConfig,
   searchMemory,
   stripOpenClawInjectedPrefix,
 } from "./lib/memos-cloud-api.js";
@@ -53,6 +55,21 @@ function getEffectiveAgentId(cfg, ctx) {
   return agentId === "main" ? undefined : agentId;
 }
 
+export function extractDirectSessionUserId(sessionKey) {
+  if (!sessionKey || typeof sessionKey !== "string") return "";
+  const parts = sessionKey.split(":");
+  const directIndex = parts.lastIndexOf("direct");
+  if (directIndex === -1) return "";
+  return parts[directIndex + 1] || "";
+}
+
+export function resolveMemosUserId(cfg, ctx) {
+  const fallback = cfg?.userId || "openclaw-user";
+  if (!cfg?.useDirectSessionUserId) return fallback;
+  const directUserId = extractDirectSessionUserId(ctx?.sessionKey);
+  return directUserId || fallback;
+}
+
 function resolveConversationId(cfg, ctx) {
   if (cfg.conversationId) return cfg.conversationId;
   // TODO: consider binding conversation_id directly to OpenClaw sessionId (prefer ctx.sessionId).
@@ -65,7 +82,7 @@ function resolveConversationId(cfg, ctx) {
   return `${prefix}openclaw-${Date.now()}${dynamicSuffix}${suffix}`;
 }
 
-function buildSearchPayload(cfg, prompt, ctx) {
+export function buildSearchPayload(cfg, prompt, ctx) {
   const cleanPrompt = stripOpenClawInjectedPrefix(prompt);
   const queryRaw = `${cfg.queryPrefix || ""}${cleanPrompt}`;
   const query =
@@ -74,7 +91,7 @@ function buildSearchPayload(cfg, prompt, ctx) {
       : queryRaw;
 
   const payload = {
-    user_id: cfg.userId,
+    user_id: resolveMemosUserId(cfg, ctx),
     query,
     source: MEMOS_SOURCE,
   };
@@ -113,9 +130,9 @@ function buildSearchPayload(cfg, prompt, ctx) {
   return payload;
 }
 
-function buildAddMessagePayload(cfg, messages, ctx) {
+export function buildAddMessagePayload(cfg, messages, ctx) {
   const payload = {
-    user_id: cfg.userId,
+    user_id: resolveMemosUserId(cfg, ctx),
     conversation_id: resolveConversationId(cfg, ctx),
     messages,
     source: MEMOS_SOURCE,
@@ -326,20 +343,20 @@ async function callRecallFilterModel(cfg, userPrompt, candidatePayload) {
   };
 
   let lastError;
-  const retries = Number.isFinite(cfg.recallFilterRetries) ? Math.max(0, cfg.recallFilterRetries) : 0;
-  const timeoutMs = Number.isFinite(cfg.recallFilterTimeoutMs) ? Math.max(1000, cfg.recallFilterTimeoutMs) : 6000;
+  const retries = Number.isFinite(cfg.recallFilterRetries) ? Math.max(0, cfg.recallFilterRetries) : 1;
+  const timeoutMs = Number.isFinite(cfg.recallFilterTimeoutMs) ? Math.max(1000, cfg.recallFilterTimeoutMs) : 30000;
 
   for (let attempt = 0; attempt <= retries; attempt += 1) {
+    let timeoutId;
     try {
       const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+      timeoutId = setTimeout(() => controller.abort(), timeoutMs);
       const res = await fetch(`${cfg.recallFilterBaseUrl}/chat/completions`, {
         method: "POST",
         headers,
         body: JSON.stringify(body),
         signal: controller.signal,
       });
-      clearTimeout(timeoutId);
       if (!res.ok) {
         throw new Error(`HTTP ${res.status}`);
       }
@@ -351,10 +368,17 @@ async function callRecallFilterModel(cfg, userPrompt, candidatePayload) {
       }
       return parsed;
     } catch (err) {
-      lastError = err;
+      const isAbort = err?.name === "AbortError" || /aborted/i.test(String(err?.message ?? err));
+      lastError = isAbort
+        ? new Error(
+            `timed out after ${timeoutMs}ms (raise recallFilterTimeoutMs; local LLMs often need 30s+ on cold start)`,
+          )
+        : err;
       if (attempt < retries) {
         await sleep(120 * (attempt + 1));
       }
+    } finally {
+      if (timeoutId !== undefined) clearTimeout(timeoutId);
     }
   }
   throw lastError;
@@ -375,7 +399,13 @@ async function maybeFilterRecallData(cfg, data, userPrompt, log) {
 
   try {
     const decision = await callRecallFilterModel(cfg, userPrompt, lists.candidatePayload);
-    return applyRecallDecision(data, decision, lists);
+    const filtered = applyRecallDecision(data, decision, lists);
+    log.info?.(
+      `[memos-cloud] recall filter applied: memory ${lists.memoryList.length}->${filtered.memory_detail_list?.length ?? 0}, ` +
+        `preference ${lists.preferenceList.length}->${filtered.preference_detail_list?.length ?? 0}, ` +
+        `tool_memory ${lists.toolList.length}->${filtered.tool_memory_detail_list?.length ?? 0}`,
+    );
+    return filtered;
   } catch (err) {
     log.warn?.(`[memos-cloud] recall filter failed: ${String(err)}`);
     return cfg.recallFilterFailOpen ? data : { ...data, memory_detail_list: [], preference_detail_list: [], tool_memory_detail_list: [] };
@@ -400,6 +430,15 @@ export default {
       log.warn?.(`[memos-cloud] No .env found in ${searchPaths}; falling back to process env or plugin config.`);
     }
 
+    if (cfg.multiAgentMode && cfg.allowedAgents?.length > 0) {
+      log.info?.(`[memos-cloud] Multi-agent mode enabled. Allowed agents: [${cfg.allowedAgents.join(", ")}]`);
+    }
+
+    const overrideAgentIds = Object.keys(cfg._agentOverrides || {});
+    if (overrideAgentIds.length > 0) {
+      log.info?.(`[memos-cloud] Per-agent overrides configured for: [${overrideAgentIds.join(", ")}]`);
+    }
+
     if (cfg.conversationSuffixMode === "counter" && cfg.resetOnNew) {
       if (api.config?.hooks?.internal?.enabled !== true) {
         log.warn?.("[memos-cloud] command:new hook requires hooks.internal.enabled = true");
@@ -419,24 +458,29 @@ export default {
     }
 
     api.on("before_agent_start", async (event, ctx) => {
-      if (!cfg.recallEnabled) return;
+      if (!isAgentAllowed(cfg, ctx)) {
+        log.info?.(`[memos-cloud] recall skipped: agent "${ctx?.agentId}" not in allowedAgents [${cfg.allowedAgents?.join(", ")}]`);
+        return;
+      }
+      const agentCfg = resolveAgentConfig(cfg, ctx?.agentId);
+      if (!agentCfg.recallEnabled) return;
       const userPrompt = stripOpenClawInjectedPrefix(event?.prompt || "");
       if (!userPrompt || userPrompt.length < 3) return;
-      if (!cfg.apiKey) {
+      if (!agentCfg.apiKey) {
         warnMissingApiKey(log, "recall");
         return;
       }
 
       try {
-        const payload = buildSearchPayload(cfg, userPrompt, ctx);
-        const result = await searchMemory(cfg, payload);
+        const payload = buildSearchPayload(agentCfg, userPrompt, ctx);
+        const result = await searchMemory(agentCfg, payload);
         const resultData = extractResultData(result);
         if (!resultData) return;
-        const filteredData = await maybeFilterRecallData(cfg, resultData, userPrompt, log);
+        const filteredData = await maybeFilterRecallData(agentCfg, resultData, userPrompt, log);
         const hookResult = formatRecallHookResult({ data: filteredData }, {
           wrapTagBlocks: true,
           relativity: payload.relativity,
-          maxItemChars: cfg.maxItemChars,
+          maxItemChars: agentCfg.maxItemChars,
         });
         if (!hookResult.appendSystemContext && !hookResult.prependContext) return;
 
@@ -447,29 +491,34 @@ export default {
     });
 
     api.on("agent_end", async (event, ctx) => {
-      if (!cfg.addEnabled) return;
+      if (!isAgentAllowed(cfg, ctx)) {
+        log.info?.(`[memos-cloud] add skipped: agent "${ctx?.agentId}" not in allowedAgents [${cfg.allowedAgents?.join(", ")}]`);
+        return;
+      }
+      const agentCfg = resolveAgentConfig(cfg, ctx?.agentId);
+      if (!agentCfg.addEnabled) return;
       if (!event?.success || !event?.messages?.length) return;
-      if (!cfg.apiKey) {
+      if (!agentCfg.apiKey) {
         warnMissingApiKey(log, "add");
         return;
       }
 
       const now = Date.now();
-      if (cfg.throttleMs && now - lastCaptureTime < cfg.throttleMs) {
+      if (agentCfg.throttleMs && now - lastCaptureTime < agentCfg.throttleMs) {
         return;
       }
       lastCaptureTime = now;
 
       try {
         const messages =
-          cfg.captureStrategy === "full_session"
-            ? pickFullSessionMessages(event.messages, cfg)
-            : pickLastTurnMessages(event.messages, cfg);
+          agentCfg.captureStrategy === "full_session"
+            ? pickFullSessionMessages(event.messages, agentCfg)
+            : pickLastTurnMessages(event.messages, agentCfg);
 
         if (!messages.length) return;
 
-        const payload = buildAddMessagePayload(cfg, messages, ctx);
-        await addMessage(cfg, payload);
+        const payload = buildAddMessagePayload(agentCfg, messages, ctx);
+        await addMessage(agentCfg, payload);
       } catch (err) {
         log.warn?.(`[memos-cloud] add failed: ${String(err)}`);
       }

package/lib/memos-cloud-api.js

@@ -157,6 +157,28 @@ function parseNumber(value, fallback) {
   return Number.isFinite(n) ? n : fallback;
 }
 
+function parseStringArray(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) return value.map((v) => String(v).trim()).filter(Boolean);
+  return String(value)
+    .split(",")
+    .map((s) => s.trim().replace(/^["']|["']$/g, ""))
+    .filter(Boolean);
+}
+
+function parseJsonObject(value) {
+  if (!value || typeof value !== "string") return null;
+  try {
+    const parsed = JSON.parse(value);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+    // ignore parse error
+  }
+  return null;
+}
+
 export function buildConfig(pluginConfig = {}) {
   const cfg = pluginConfig ?? {};
 
@@ -184,6 +206,10 @@ export function buildConfig(pluginConfig = {}) {
     parseBool(loadEnvVar("MEMOS_MULTI_AGENT_MODE"), false),
   );
 
+  const allowedAgents = parseStringArray(
+    cfg.allowedAgents ?? loadEnvVar("MEMOS_ALLOWED_AGENTS"),
+  );
+
   const recallFilterEnabled = parseBool(
     cfg.recallFilterEnabled,
     parseBool(loadEnvVar("MEMOS_RECALL_FILTER_ENABLED"), false),
@@ -200,6 +226,10 @@ export function buildConfig(pluginConfig = {}) {
       ? parseBool(loadEnvVar("MEMOS_INCLUDE_ASSISTANT"), true)
       : cfg.includeAssistant !== false;
   const maxMessageChars = cfg.maxMessageChars ?? parseNumber(loadEnvVar("MEMOS_MAX_MESSAGE_CHARS"), 20000);
+  const useDirectSessionUserId = parseBool(
+    cfg.useDirectSessionUserId,
+    parseBool(loadEnvVar("MEMOS_USE_DIRECT_SESSION_USER_ID"), false),
+  );
 
   return {
     baseUrl: baseUrl.replace(/\/+$/, ""),
@@ -209,6 +239,7 @@ export function buildConfig(pluginConfig = {}) {
     conversationIdPrefix,
     conversationIdSuffix,
     conversationSuffixMode,
+    useDirectSessionUserId,
     recallGlobal,
     resetOnNew,
     envFileStatus: getEnvFileStatus(),
@@ -230,15 +261,16 @@ export function buildConfig(pluginConfig = {}) {
       return v ? parseFloat(v) : 0.45;
     })()),
     filter: cfg.filter,
-    knowledgebaseIds: cfg.knowledgebaseIds ?? [],
-    tags: cfg.tags ?? ["openclaw"],
+    knowledgebaseIds: cfg.knowledgebaseIds ?? (loadEnvVar("MEMOS_KNOWLEDGEBASE_IDS") ? parseStringArray(loadEnvVar("MEMOS_KNOWLEDGEBASE_IDS")) : []),
+    tags: cfg.tags ?? (loadEnvVar("MEMOS_TAGS") ? parseStringArray(loadEnvVar("MEMOS_TAGS")) : ["openclaw"]),
     info: cfg.info ?? {},
     agentId: cfg.agentId,
     appId: cfg.appId,
     allowPublic: cfg.allowPublic ?? false,
-    allowKnowledgebaseIds: cfg.allowKnowledgebaseIds ?? [],
+    allowKnowledgebaseIds: cfg.allowKnowledgebaseIds ?? (loadEnvVar("MEMOS_ALLOW_KNOWLEDGEBASE_IDS") ? parseStringArray(loadEnvVar("MEMOS_ALLOW_KNOWLEDGEBASE_IDS")) : []),
     asyncMode,
     multiAgentMode,
+    allowedAgents,
     recallFilterEnabled,
     recallFilterBaseUrl:
       (cfg.recallFilterBaseUrl ?? loadEnvVar("MEMOS_RECALL_FILTER_BASE_URL") ?? "").replace(/\/+$/, ""),
@@ -246,9 +278,9 @@ export function buildConfig(pluginConfig = {}) {
     recallFilterModel: cfg.recallFilterModel ?? loadEnvVar("MEMOS_RECALL_FILTER_MODEL") ?? "",
     recallFilterTimeoutMs: parseNumber(
       cfg.recallFilterTimeoutMs ?? loadEnvVar("MEMOS_RECALL_FILTER_TIMEOUT_MS"),
-      6000,
+      30000,
     ),
-    recallFilterRetries: parseNumber(cfg.recallFilterRetries ?? loadEnvVar("MEMOS_RECALL_FILTER_RETRIES"), 0),
+    recallFilterRetries: parseNumber(cfg.recallFilterRetries ?? loadEnvVar("MEMOS_RECALL_FILTER_RETRIES"), 1),
     recallFilterCandidateLimit:
       parseNumber(cfg.recallFilterCandidateLimit ?? loadEnvVar("MEMOS_RECALL_FILTER_CANDIDATE_LIMIT"), 30),
     recallFilterMaxItemChars:
@@ -257,9 +289,35 @@ export function buildConfig(pluginConfig = {}) {
     timeoutMs: cfg.timeoutMs ?? 5000,
     retries: cfg.retries ?? 1,
     throttleMs,
+    _agentOverrides: cfg.agentOverrides ?? parseJsonObject(loadEnvVar("MEMOS_AGENT_OVERRIDES")) ?? {},
   };
 }
 
+const AGENT_OVERRIDABLE_KEYS = [
+  "knowledgebaseIds", "memoryLimitNumber", "preferenceLimitNumber",
+  "includePreference", "includeToolMemory", "toolMemoryLimitNumber",
+  "relativity",
+  "recallEnabled", "addEnabled", "captureStrategy", "queryPrefix",
+  "maxItemChars", "maxMessageChars", "includeAssistant",
+  "recallGlobal", "recallFilterEnabled", "recallFilterModel",
+  "recallFilterBaseUrl", "recallFilterApiKey",
+  "allowKnowledgebaseIds", "tags", "throttleMs",
+];
+
+export function resolveAgentConfig(baseCfg, agentId) {
+  if (!agentId || !baseCfg._agentOverrides) return baseCfg;
+  const overrides = baseCfg._agentOverrides[agentId];
+  if (!overrides || typeof overrides !== "object") return baseCfg;
+
+  const merged = { ...baseCfg };
+  for (const key of AGENT_OVERRIDABLE_KEYS) {
+    if (key in overrides) {
+      merged[key] = overrides[key];
+    }
+  }
+  return merged;
+}
+
 export async function callApi({ baseUrl, apiKey, timeoutMs = 5000, retries = 1 }, path, body) {
   if (!apiKey) {
     throw new Error("Missing MEMOS API key (Token auth)");
@@ -317,6 +375,13 @@ function sanitizeAddMessageEntry(entry) {
   return { ...entry, content };
 }
 
+export function isAgentAllowed(cfg, ctx) {
+  if (!cfg.multiAgentMode) return true;
+  if (!cfg.allowedAgents || cfg.allowedAgents.length === 0) return true;
+  const agentId = ctx?.agentId || cfg.agentId || "main";
+  return cfg.allowedAgents.includes(agentId);
+}
+
 export async function searchMemory(cfg, payload) {
   return callApi(cfg, "/search/memory", sanitizeSearchPayload(payload));
 }
@@ -518,12 +583,16 @@ function sanitizeInlineText(text) {
   return String(text).replace(/\r?\n+/g, " ").trim();
 }
 
+function resolveDisplayTime(item) {
+  return item?.update_time ?? item?.create_time;
+}
+
 function formatMemoryLine(item, text, options = {}) {
   const cleaned = sanitizeInlineText(text);
   if (!cleaned) return "";
   const maxChars = options.maxItemChars;
   const truncated = truncate(cleaned, maxChars);
-  const time = formatTime(item?.create_time);
+  const time = formatTime(resolveDisplayTime(item));
   if (time) return `   -[${time}] ${truncated}`;
   return `   - ${truncated}`;
 }
@@ -533,7 +602,7 @@ function formatPreferenceLine(item, text, options = {}) {
   if (!cleaned) return "";
   const maxChars = options.maxItemChars;
   const truncated = truncate(cleaned, maxChars);
-  const time = formatTime(item?.create_time);
+  const time = formatTime(resolveDisplayTime(item));
   const type = normalizePreferenceType(item?.preference_type);
   const typeLabel = type ? ` [${type}]` : "";
   if (time) return `   -[${time}]${typeLabel} ${truncated}`;

package/moltbot.plugin.json

@@ -2,7 +2,7 @@
   "id": "memos-cloud-openclaw-plugin",
   "name": "MemOS Cloud OpenClaw Plugin",
   "description": "MemOS Cloud recall + add memory via lifecycle hooks",
-  "version": "0.1.10-beta.0",
+  "version": "0.1.11-beta.0",
   "kind": "lifecycle",
   "main": "./index.js",
   "configSchema": {
@@ -41,6 +41,11 @@
         ],
         "default": "none"
       },
+      "useDirectSessionUserId": {
+        "type": "boolean",
+        "description": "When enabled, direct-session keys like agent:main:<provider>:direct:<id> use the direct id as MemOS user_id instead of the default configured userId.",
+        "default": false
+      },
       "resetOnNew": {
         "type": "boolean",
         "default": true
@@ -109,7 +114,47 @@
       },
       "filter": {
         "type": "object",
-        "description": "MemOS search filter"
+        "description": "MemOS search filter",
+        "additionalProperties": true
+      },
+      "relativity": {
+        "type": "number",
+        "description": "Search relativity threshold",
+        "default": 0.45
+      },
+      "recallFilterEnabled": {
+        "type": "boolean",
+        "default": false
+      },
+      "recallFilterBaseUrl": {
+        "type": "string",
+        "description": "OpenAI-compatible API base URL for recall filtering"
+      },
+      "recallFilterApiKey": {
+        "type": "string"
+      },
+      "recallFilterModel": {
+        "type": "string"
+      },
+      "recallFilterTimeoutMs": {
+        "type": "integer",
+        "default": 30000
+      },
+      "recallFilterRetries": {
+        "type": "integer",
+        "default": 1
+      },
+      "recallFilterCandidateLimit": {
+        "type": "integer",
+        "default": 30
+      },
+      "recallFilterMaxItemChars": {
+        "type": "integer",
+        "default": 500
+      },
+      "recallFilterFailOpen": {
+        "type": "boolean",
+        "default": true
       },
       "knowledgebaseIds": {
         "type": "array",
@@ -134,6 +179,13 @@
         "type": "boolean",
         "default": false
       },
+      "allowedAgents": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        },
+        "description": "When multiAgentMode is true, only these agent IDs will activate the memory plugin. Comma-separated in env var MEMOS_ALLOWED_AGENTS. Empty list means all agents are allowed."
+      },
       "appId": {
         "type": "string"
       },
@@ -162,6 +214,108 @@
       "throttleMs": {
         "type": "integer",
         "default": 0
+      },
+      "agentOverrides": {
+        "type": "object",
+        "description": "Per-agent config overrides. Keys are agent IDs, values override global defaults for that agent.",
+        "additionalProperties": {
+          "type": "object",
+          "properties": {
+            "knowledgebaseIds": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            "memoryLimitNumber": {
+              "type": "integer"
+            },
+            "preferenceLimitNumber": {
+              "type": "integer"
+            },
+            "includePreference": {
+              "type": "boolean"
+            },
+            "includeToolMemory": {
+              "type": "boolean"
+            },
+            "toolMemoryLimitNumber": {
+              "type": "integer"
+            },
+            "includeSkill": {
+              "type": "boolean"
+            },
+            "skillLimitNumber": {
+              "type": "integer"
+            },
+            "relativity": {
+              "type": "number"
+            },
+            "filter": {
+              "type": "object",
+              "additionalProperties": true
+            },
+            "recallEnabled": {
+              "type": "boolean"
+            },
+            "addEnabled": {
+              "type": "boolean"
+            },
+            "captureStrategy": {
+              "type": "string",
+              "enum": [
+                "last_turn",
+                "full_session"
+              ]
+            },
+            "queryPrefix": {
+              "type": "string"
+            },
+            "maxQueryChars": {
+              "type": "integer"
+            },
+            "maxItemChars": {
+              "type": "integer"
+            },
+            "maxMessageChars": {
+              "type": "integer"
+            },
+            "includeAssistant": {
+              "type": "boolean"
+            },
+            "recallGlobal": {
+              "type": "boolean"
+            },
+            "recallFilterEnabled": {
+              "type": "boolean"
+            },
+            "recallFilterModel": {
+              "type": "string"
+            },
+            "recallFilterBaseUrl": {
+              "type": "string"
+            },
+            "recallFilterApiKey": {
+              "type": "string"
+            },
+            "allowKnowledgebaseIds": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            "tags": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            "throttleMs": {
+              "type": "integer"
+            }
+          },
+          "additionalProperties": false
+        }
       }
     },
     "additionalProperties": false