@mem9/mem9 0.3.5-rc.5 → 0.3.6

package/hooks.ts

@@ -130,11 +130,14 @@ function formatMemoriesBlock(memories: Memory[]): string {
   let idx = 1;
 
   const formatMem = (m: Memory): string => {
-    const tags = m.tags?.length ? ` [${m.tags.join(", ")}]` : "";
+    const tagStr = m.tags?.length ? `[${m.tags.join(", ")}]` : "";
+    const age = m.relative_age ? `(${m.relative_age})` : "";
+    const middle = [tagStr, age].filter(Boolean).join(" ");
+    const sep = middle ? " " + middle + " " : " ";
     const content = m.content.length > MAX_CONTENT_LEN
       ? m.content.slice(0, MAX_CONTENT_LEN) + "..."
       : m.content;
-    return `${idx++}.${tags} ${escapeForPrompt(content)}`;
+    return `${idx++}.${sep}${escapeForPrompt(content)}`;
   };
 
   if (pinned.length > 0) {

package/index.ts

@@ -3,6 +3,7 @@ import { ServerBackend } from "./server-backend.js";
 import { registerHooks } from "./hooks.js";
 import type {
   PluginConfig,
+  Memory,
   CreateMemoryInput,
   UpdateMemoryInput,
   SearchInput,
@@ -26,6 +27,13 @@ function jsonResult(data: unknown) {
   }
 }
 
+interface MemoryCapability {
+  search: (query: string, opts?: { limit?: number }) => Promise<{ data: Memory[]; total: number }>;
+  store: (content: string, opts?: { tags?: string[]; source?: string }) => Promise<unknown>;
+  get: (id: string) => Promise<Memory | null>;
+  remove: (id: string) => Promise<boolean>;
+}
+
 interface OpenClawPluginApi {
   pluginConfig?: unknown;
   logger: {
@@ -36,6 +44,7 @@ interface OpenClawPluginApi {
     factory: ToolFactory | (() => AnyAgentTool[]),
     opts: { names: string[] }
   ) => void;
+  registerCapability?: (slot: string, capability: MemoryCapability) => void;
   on: (hookName: string, handler: (...args: unknown[]) => unknown, opts?: { priority?: number }) => void;
 }
 
@@ -123,6 +132,10 @@ function buildTools(backend: MemoryBackend): AnyAgentTool[] {
             description: "Max results (default 20, max 200)",
           },
           offset: { type: "number", description: "Pagination offset" },
+          memory_type: {
+            type: "string",
+            description: "Comma-separated memory types to filter by (e.g. insight,pinned)",
+          },
         },
         required: [],
       },
@@ -238,7 +251,7 @@ const mnemoPlugin = {
   description:
     "AI agent memory — server mode (mnemo-server) with hybrid vector + keyword search.",
 
-  async register(api: OpenClawPluginApi) {
+  register(api: OpenClawPluginApi) {
     const cfg = (api.pluginConfig ?? {}) as PluginConfig;
     const effectiveApiUrl = cfg.apiUrl ?? DEFAULT_API_URL;
     if (!cfg.apiUrl) {
@@ -284,13 +297,32 @@ const mnemoPlugin = {
 
     api.registerTool(factory, { names: toolNames });
 
-    // Register hooks with a lazy backend for lifecycle memory management.
-    // Uses the default workspace/agent context for hook-triggered operations.
+    // Shared lazy backend for hooks and capability registration.
     const hookBackend = new LazyServerBackend(
       effectiveApiUrl,
       () => resolveAPIKey(hookAgentId),
       hookAgentId,
     );
+
+    // Register memory capability so OpenClaw 2026.4.2+ binds this plugin to
+    // the memory slot. Without this, the plugin is treated as a legacy
+    // hook-only plugin and automatic context injection won't work.
+    // Guard with typeof check for backward compatibility with older hosts.
+    if (typeof api.registerCapability === "function") {
+      api.registerCapability("memory", {
+        search: async (query, opts) => {
+          const result = await hookBackend.search({ q: query, limit: opts?.limit });
+          return { data: result.data, total: result.total };
+        },
+        store: async (content, opts) => {
+          return hookBackend.store({ content, tags: opts?.tags, source: opts?.source });
+        },
+        get: (id) => hookBackend.get(id),
+        remove: (id) => hookBackend.remove(id),
+      });
+    }
+
+    // Register hooks with lazy backend for lifecycle memory management.
     registerHooks(api, hookBackend, api.logger, {
       maxIngestBytes: cfg.maxIngestBytes,
       fallbackAgentId: hookAgentId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mem9/mem9",
-  "version": "0.3.5-rc.5",
+  "version": "0.3.6",
   "description": "OpenClaw shared memory plugin — cloud-persistent memory with hybrid vector + keyword search via mnemo-server",
   "type": "module",
   "license": "Apache-2.0",

package/server-backend.ts

@@ -67,6 +67,7 @@ export class ServerBackend implements MemoryBackend {
     if (input.source) params.set("source", input.source);
     if (input.limit != null) params.set("limit", String(input.limit));
     if (input.offset != null) params.set("offset", String(input.offset));
+    if (input.memory_type) params.set("memory_type", input.memory_type);
 
     const qs = params.toString();
     const raw = await this.request<{

package/types.ts

@@ -31,6 +31,8 @@ export interface Memory {
   state?: string;
   agent_id?: string;
   session_id?: string;
+
+  relative_age?: string;
 }
 
 export interface SearchResult {
@@ -60,6 +62,7 @@ export interface SearchInput {
   source?: string;
   limit?: number;
   offset?: number;
+  memory_type?: string;
 }
 
 export interface IngestMessage {