@mem9/mem9 0.4.6 → 0.4.7

package/README.md

@@ -1,8 +1,6 @@
-# OpenClaw Plugin for mem9
+# OpenClaw Plugin for mnemos
 
-Memory plugin for [OpenClaw](https://github.com/openclaw) — replaces the built-in memory slot with cloud-persistent shared memory. Runs in server mode only, connecting to `mnemo-server` via `apiUrl` + `apiKey` (preferred) or legacy `tenantID`. Optional `provisionToken` and `provisionQueryParams` are used only during first-time create-new setup before an explicit `apiKey` is configured.
-
-When `apiKey` is absent during create-new onboarding, the plugin does not auto-provision on startup. Instead, the first post-restart user message triggers exactly one create-new provision through the normal hook path. The plugin coordinates that call across concurrent OpenClaw plugin registrations on the same machine and reuses the generated key locally for future restarts tied to the same `provisionToken`.
+Memory plugin for [OpenClaw](https://github.com/openclaw) — replaces the built-in memory slot with cloud-persistent shared memory. Runs in server mode only, connecting to `mnemo-server` via `apiUrl` + `apiKey` (preferred) or legacy `tenantID`.
 
 ## 🚀 Quick Start (Server Mode)
 
@@ -22,14 +20,14 @@ curl -s -X POST http://localhost:8080/v1alpha1/mem9s \
 # {"id": "uuid"}
 ```
 
-Add mem9 to your project's `openclaw.json`:
+Add mnemo to your project's `openclaw.json`:
 
 ```json
 {
   "plugins": {
-    "slots": { "memory": "mem9" },
+    "slots": { "memory": "openclaw" },
     "entries": {
-      "mem9": {
+      "openclaw": {
         "enabled": true,
         "config": {
           "apiUrl": "http://localhost:8080",
@@ -66,8 +64,8 @@ This is a `kind: "memory"` plugin — OpenClaw's framework manages when to load/
 
 | Hook | Trigger | What it does |
 |---|---|---|
-| `before_prompt_build` | Every LLM call | Searches memories by current prompt and injects relevant ones as context |
-| `after_compaction` | After `/compact` | Logs compaction so the next prompt re-queries memories from the server |
+| `before_prompt_build` | Every LLM call | Searches memories by current prompt, injects relevant ones as context (3-min TTL cache) |
+| `after_compaction` | After `/compact` | Invalidates cache so the next prompt gets fresh memories from the database |
 | `before_reset` | Before `/reset` | Saves a session summary (last 3 user messages) as memory before context is wiped |
 | `agent_end` | Agent finishes | Auto-captures the last assistant response as memory (if substantial) |
 
@@ -75,7 +73,7 @@ This is a `kind: "memory"` plugin — OpenClaw's framework manages when to load/
 
 | Tool | Description |
 |---|---|
-| `memory_store` | Store a new memory |
+| `memory_store` | Store a new memory (upsert by key) |
 | `memory_search` | Hybrid vector + keyword search (or keyword-only) |
 | `memory_get` | Retrieve a single memory by ID |
 | `memory_update` | Update an existing memory |
@@ -93,7 +91,7 @@ This is a `kind: "memory"` plugin — OpenClaw's framework manages when to load/
 ### Method A: npm install (Recommended)
 
 ```bash
-openclaw plugins install @mem9/mem9
+openclaw plugins install @mem9/openclaw
 ```
 
 ### Method B: From source
@@ -106,7 +104,7 @@ npm install
 
 ### Configure OpenClaw
 
-Add mem9 to your project's `openclaw.json`:
+Add mnemo to your project's `openclaw.json`:
 
 OpenClaw is often deployed across teams with multiple agents. Server mode gives you:
 
@@ -141,10 +139,10 @@ Each agent uses the same `apiKey` for the shared memory pool. The plugin sends t
 {
   "plugins": {
     "slots": {
-      "memory": "mem9"
+      "memory": "openclaw"
     },
     "entries": {
-      "mem9": {
+      "openclaw": {
         "enabled": true,
         "config": {
           "apiUrl": "http://your-server:8080",
@@ -162,8 +160,8 @@ That's it. The server handles scoping and conflict resolution. Conceptually, the
 
 Start OpenClaw. You should see:
 
-```text
-[mem9] Server mode (v1alpha2)
+```
+[mem9] Server mode
 ```
 
 If you see `[mem9] No mode configured...`, check your `openclaw.json` config.
@@ -176,13 +174,11 @@ Defined in `openclaw.plugin.json`:
 |---|---|---|
 | `apiUrl` | string | mnemo-server URL |
 | `apiKey` | string | Preferred key. Uses `/v1alpha2/mem9s/...` with `X-API-Key` header |
-| `provisionToken` | string | Optional one-time create-new token used locally to ensure the first-message create-new provision runs only once and is reused on this machine until an explicit `apiKey` is configured |
-| `provisionQueryParams` | object | Optional `utm_*` map forwarded only to the initial `POST /v1alpha1/mem9s` request made during create-new when `apiKey` is absent |
 | `defaultTimeoutMs` | number | Default timeout for non-search mem9 API requests in milliseconds. Default: `8000` |
 | `searchTimeoutMs` | number | Timeout for `memory_search` and automatic recall search in milliseconds. Default: `15000` |
 | `tenantID` | string | Legacy alias for `apiKey`. The plugin still uses `/v1alpha2/mem9s/...` with `X-API-Key`. |
 
-> **Note**: `apiKey` takes precedence when both fields are set. If only `tenantID` is present, the plugin treats it as a legacy alias for `apiKey`, still uses v1alpha2, and logs a deprecation warning once at startup. `provisionToken` and `provisionQueryParams` are ignored after an `apiKey` is already configured, and non-`utm_*` keys are dropped before the provision request is sent. During create-new onboarding, the plugin shares one in-flight provision result across concurrent local registrations and reuses the persisted result for the same `provisionToken`, so repeated reloads or repeated setup retries do not create multiple keys.
+> **Note**: `apiKey` takes precedence when both fields are set. If only `tenantID` is present, the plugin treats it as a legacy alias for `apiKey`, still uses v1alpha2, and logs a deprecation warning once at startup.
 
 ## Timeout Behavior
 
@@ -217,7 +213,7 @@ Example:
 openclaw-plugin/
 ├── README.md              # This file
 ├── openclaw.plugin.json   # Plugin metadata + config schema
-├── package.json           # npm package (@mem9/mem9)
+├── package.json           # npm package (@mem9/openclaw)
 ├── index.ts               # Plugin entry point + tool registration
 ├── backend.ts             # MemoryBackend interface
 ├── server-backend.ts      # Server mode: fetch → mnemo API
@@ -231,6 +227,5 @@ openclaw-plugin/
 |---|---|---|
 | `No mode configured` | Missing config | Add `apiUrl` and `apiKey` (or legacy `tenantID`) to plugin config |
 | `Server mode requires...` | Missing key | Add `apiKey` (or legacy `tenantID`) to config |
-| Multiple auto-provisioned keys appear during create-new | Setup retriggered create-new provisioning before the first result was reused, or an older plugin still auto-provisions on startup | Upgrade to `@mem9/mem9@0.4.7+`; newer builds provision only from the first post-restart user message and reuse one local result across duplicate setup retries |
 | Search requests time out | Hybrid/vector search exceeds plugin timeout | Increase `searchTimeoutMs` in plugin config |
-| Plugin not loading | Not in memory slot | Set `"slots": {"memory": "mem9"}` in openclaw.json |
+| Plugin not loading | Not in memory slot | Set `"slots": {"memory": "openclaw"}` in openclaw.json |

package/backend.ts

@@ -9,20 +9,6 @@ import type {
   IngestResult,
 } from "./types.js";
 
-export class PendingProvisionError extends Error {
-  constructor(
-    message = "mem9 create-new setup is waiting for the first post-restart message to finish provisioning",
-  ) {
-    super(message);
-    this.name = "PendingProvisionError";
-  }
-}
-
-export function isPendingProvisionError(err: unknown): err is PendingProvisionError {
-  return err instanceof PendingProvisionError
-    || (err instanceof Error && err.name === "PendingProvisionError");
-}
-
 /**
  * MemoryBackend — the abstraction that tools and hooks call through.
  */

package/hooks.ts

@@ -11,7 +11,7 @@
  * Reference: OpenClaw's built-in memory-lancedb extension uses the same pattern.
  */
 
-import { isPendingProvisionError, type MemoryBackend } from "./backend.js";
+import type { MemoryBackend } from "./backend.js";
 import type { Memory, IngestMessage } from "./types.js";
 
 // ---------------------------------------------------------------------------
@@ -169,11 +169,7 @@ export function registerHooks(
   api: HookApi,
   backend: MemoryBackend,
   logger: Logger,
-  options?: {
-    maxIngestBytes?: number;
-    fallbackAgentId?: string;
-    provisionForCreateNew?: () => Promise<string>;
-  },
+  options?: { maxIngestBytes?: number; fallbackAgentId?: string },
 ): void {
   const maxIngestBytes = options?.maxIngestBytes ?? DEFAULT_MAX_INGEST_BYTES;
 
@@ -186,9 +182,6 @@ export function registerHooks(
       try {
         const evt = event as { prompt?: string };
         const prompt = evt?.prompt;
-        if (options?.provisionForCreateNew) {
-          await options.provisionForCreateNew();
-        }
         if (!prompt || prompt.length < MIN_PROMPT_LEN) return;
 
         const result = await backend.search({ q: prompt, limit: MAX_INJECT });
@@ -202,9 +195,6 @@ export function registerHooks(
           prependContext: formatMemoriesBlock(memories),
         };
       } catch (err) {
-        if (isPendingProvisionError(err)) {
-          return;
-        }
         // Graceful degradation — never block the LLM call
         logger.error(`[mem9] before_prompt_build failed: ${String(err)}`);
       }
@@ -255,9 +245,6 @@ export function registerHooks(
 
       logger.info("[mem9] Session context saved before reset");
     } catch (err) {
-      if (isPendingProvisionError(err)) {
-        return;
-      }
       // Best-effort — never block /reset
       logger.error(`[mem9] before_reset save failed: ${String(err)}`);
     }
@@ -359,10 +346,7 @@ export function registerHooks(
           `[mem9] Ingested session: memories_changed=${result.memories_changed}, status=${result.status}`
         );
       }
-    } catch (err) {
-      if (isPendingProvisionError(err)) {
-        return;
-      }
+    } catch {
       // Best-effort — never fail the agent end phase
     }
   });

package/index.ts

@@ -1,9 +1,4 @@
-import { createHash } from "node:crypto";
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-
-import { PendingProvisionError, isPendingProvisionError, type MemoryBackend } from "./backend.js";
+import type { MemoryBackend } from "./backend.js";
 import {
   DEFAULT_SEARCH_TIMEOUT_MS,
   DEFAULT_TIMEOUT_MS,
@@ -23,28 +18,6 @@ import type {
 
 const DEFAULT_API_URL = "https://api.mem9.ai";
 const TIMEOUT_FIELDS = ["defaultTimeoutMs", "searchTimeoutMs"] as const;
-const SHARED_PROVISION_DIR = path.join(os.homedir(), ".openclaw", "mem9", "provision");
-const SHARED_PROVISION_POLL_INTERVAL_MS = 250;
-const sharedProvisionPromises = new Map<string, Promise<string>>();
-
-type SharedProvisionState =
-  | {
-      status: "pending";
-      startedAt: number;
-      pid: number;
-    }
-  | {
-      status: "done";
-      startedAt: number;
-      finishedAt: number;
-      apiKey: string;
-    }
-  | {
-      status: "error";
-      startedAt: number;
-      finishedAt: number;
-      error: string;
-    };
 
 function normalizeTimeoutMs(
   value: unknown,
@@ -102,225 +75,6 @@ function jsonResult(data: unknown) {
   }
 }
 
-function errorMessage(err: unknown): string {
-  return err instanceof Error ? err.message : String(err);
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function sharedProvisionKey(
-  apiUrl: string,
-  provisionQueryParams: Record<string, string>,
-  provisionToken: string,
-): string {
-  const normalizedProvisionQueryParams = Object.fromEntries(
-    Object.entries(provisionQueryParams).sort(([left], [right]) => left.localeCompare(right)),
-  );
-
-  return createHash("sha256")
-    .update(
-      JSON.stringify({
-        apiUrl,
-        provisionToken,
-        provisionQueryParams: normalizedProvisionQueryParams,
-      }),
-    )
-    .digest("hex");
-}
-
-function sharedProvisionStatePath(sharedKey: string): string {
-  return path.join(SHARED_PROVISION_DIR, `${sharedKey}.json`);
-}
-
-async function readSharedProvisionState(filePath: string): Promise<SharedProvisionState | null> {
-  try {
-    const raw = await readFile(filePath, "utf8");
-    const parsed = JSON.parse(raw) as Partial<SharedProvisionState>;
-    if (parsed.status === "pending" && typeof parsed.startedAt === "number") {
-      return {
-        status: "pending",
-        startedAt: parsed.startedAt,
-        pid: typeof parsed.pid === "number" ? parsed.pid : 0,
-      };
-    }
-    if (
-      parsed.status === "done"
-      && typeof parsed.startedAt === "number"
-      && typeof parsed.finishedAt === "number"
-      && typeof parsed.apiKey === "string"
-    ) {
-      return {
-        status: "done",
-        startedAt: parsed.startedAt,
-        finishedAt: parsed.finishedAt,
-        apiKey: parsed.apiKey,
-      };
-    }
-    if (
-      parsed.status === "error"
-      && typeof parsed.startedAt === "number"
-      && typeof parsed.finishedAt === "number"
-      && typeof parsed.error === "string"
-    ) {
-      return {
-        status: "error",
-        startedAt: parsed.startedAt,
-        finishedAt: parsed.finishedAt,
-        error: parsed.error,
-      };
-    }
-  } catch (err) {
-    if ((err as NodeJS.ErrnoException).code === "ENOENT") {
-      return null;
-    }
-  }
-  return null;
-}
-
-async function writeSharedProvisionState(
-  filePath: string,
-  state: SharedProvisionState,
-): Promise<void> {
-  await mkdir(path.dirname(filePath), { recursive: true });
-  await writeFile(filePath, JSON.stringify(state), "utf8");
-}
-
-async function createSharedProvisionPendingState(
-  filePath: string,
-  startedAt: number,
-): Promise<boolean> {
-  await mkdir(path.dirname(filePath), { recursive: true });
-  try {
-    await writeFile(
-      filePath,
-      JSON.stringify({
-        status: "pending",
-        startedAt,
-        pid: process.pid,
-      } satisfies SharedProvisionState),
-      { encoding: "utf8", flag: "wx" },
-    );
-    return true;
-  } catch (err) {
-    if ((err as NodeJS.ErrnoException).code === "EEXIST") {
-      return false;
-    }
-    throw err;
-  }
-}
-
-async function removeSharedProvisionState(filePath: string): Promise<void> {
-  await rm(filePath, { force: true });
-}
-
-async function waitForSharedProvisionResult(
-  filePath: string,
-  waitTimeoutMs: number,
-): Promise<string | null> {
-  const deadline = Date.now() + waitTimeoutMs;
-
-  while (true) {
-    const state = await readSharedProvisionState(filePath);
-    const now = Date.now();
-
-    if (!state) {
-      return null;
-    }
-
-    if (state.status === "done") {
-      return state.apiKey;
-    }
-
-    if (state.status === "error") {
-      await removeSharedProvisionState(filePath);
-      throw new Error(state.error);
-    }
-
-    if (now - state.startedAt > waitTimeoutMs || now >= deadline) {
-      await removeSharedProvisionState(filePath);
-      return null;
-    }
-
-    await sleep(SHARED_PROVISION_POLL_INTERVAL_MS);
-  }
-}
-
-async function resolveSharedProvisionedAPIKey(
-  apiUrl: string,
-  provisionQueryParams: Record<string, string>,
-  provisionToken: string,
-  timeouts: Required<BackendTimeouts>,
-  logger: OpenClawPluginApi["logger"],
-  registerTenant: () => Promise<string>,
-): Promise<string> {
-  const key = sharedProvisionKey(apiUrl, provisionQueryParams, provisionToken);
-  const existingPromise = sharedProvisionPromises.get(key);
-  if (existingPromise) {
-    return existingPromise;
-  }
-
-  const waitTimeoutMs = Math.max(timeouts.defaultTimeoutMs + 5_000, 30_000);
-  const filePath = sharedProvisionStatePath(key);
-  const sharedPromise = (async () => {
-    while (true) {
-      const state = await readSharedProvisionState(filePath);
-
-      if (state?.status === "done") {
-        logger.info("[mem9] reusing locally persisted create-new API key for this provisionToken");
-        return state.apiKey;
-      }
-
-      if (state?.status === "error") {
-        await removeSharedProvisionState(filePath);
-      } else if (state?.status === "pending") {
-        const now = Date.now();
-        if (now - state.startedAt > waitTimeoutMs) {
-          await removeSharedProvisionState(filePath);
-          continue;
-        }
-        logger.info("[mem9] create-new provision already in progress in another mem9 instance; waiting");
-        const sharedApiKey = await waitForSharedProvisionResult(filePath, waitTimeoutMs);
-        if (sharedApiKey) {
-          return sharedApiKey;
-        }
-        continue;
-      }
-
-      const startedAt = Date.now();
-      const acquired = await createSharedProvisionPendingState(filePath, startedAt);
-      if (!acquired) {
-        continue;
-      }
-
-      try {
-        const apiKey = await registerTenant();
-        await writeSharedProvisionState(filePath, {
-          status: "done",
-          startedAt,
-          finishedAt: Date.now(),
-          apiKey,
-        });
-        return apiKey;
-      } catch (err) {
-        await writeSharedProvisionState(filePath, {
-          status: "error",
-          startedAt,
-          finishedAt: Date.now(),
-          error: errorMessage(err),
-        });
-        throw err;
-      }
-    }
-  })().finally(() => {
-    sharedProvisionPromises.delete(key);
-  });
-
-  sharedProvisionPromises.set(key, sharedPromise);
-  return sharedPromise;
-}
-
 interface MemoryCapability {
   search: (query: string, opts?: { limit?: number }) => Promise<{ data: Memory[]; total: number }>;
   store: (content: string, opts?: { tags?: string[]; source?: string }) => Promise<unknown>;
@@ -363,9 +117,7 @@ interface AnyAgentTool {
   execute: (_id: string, params: unknown) => Promise<unknown>;
 }
 
-function buildTools(
-  backend: MemoryBackend,
-): AnyAgentTool[] {
+function buildTools(backend: MemoryBackend): AnyAgentTool[] {
   return [
     {
       name: "memory_store",
@@ -550,122 +302,43 @@ const mnemoPlugin = {
   register(api: OpenClawPluginApi) {
     const cfg = (api.pluginConfig ?? {}) as PluginConfig;
     const effectiveApiUrl = cfg.apiUrl ?? DEFAULT_API_URL;
-    const configuredProvisionToken =
-      typeof cfg.provisionToken === "string" && cfg.provisionToken.trim() !== ""
-        ? cfg.provisionToken.trim()
-        : null;
-    const provisionQueryParams = cfg.provisionQueryParams ?? {};
     const timeoutConfig = resolveTimeouts(cfg, api.logger);
-    const hookAgentId = cfg.agentName ?? "agent";
     if (!cfg.apiUrl) {
       api.logger.info(`[mem9] apiUrl not configured, using default ${DEFAULT_API_URL}`);
     }
 
     const configuredApiKey = cfg.apiKey ?? cfg.tenantID;
-    const provisionWaitTimeoutMs = Math.max(timeoutConfig.defaultTimeoutMs + 5_000, 30_000);
     if (cfg.apiKey && cfg.tenantID) {
       api.logger.info("[mem9] both apiKey and tenantID set; using apiKey");
     } else if (cfg.tenantID) {
       api.logger.info("[mem9] tenantID is deprecated; treating it as apiKey for v1alpha2");
     }
     const registerTenant = async (agentName: string): Promise<string> => {
-      const backend = new ServerBackend(
-        effectiveApiUrl,
-        "",
-        agentName,
-        {
-          timeouts: timeoutConfig,
-          provisionQueryParams,
-        },
-      );
+      const backend = new ServerBackend(effectiveApiUrl, "", agentName, timeoutConfig);
       const result = await backend.register();
       api.logger.info(
-        `[mem9] *** Auto-provisioned apiKey=${result.id} *** Save this for recovery or reconnect as apiKey`
+        `[mem9] *** Auto-provisioned apiKey=${result.id} *** Save this to your config as apiKey`
       );
       return result.id;
     };
-    let runtimeProvisionedAPIKey: string | null = null;
-    let loggedPersistedProvisionedAPIKeyReuse = false;
     let registrationPromise: Promise<string> | null = null;
-    const provisionAPIKey = (agentName: string): Promise<string> => {
-      if (configuredApiKey) {
-        return Promise.reject(
-          new Error(
-            "mem9 create-new auto-provision is only available before apiKey is configured",
-          ),
-        );
-      }
-      if (runtimeProvisionedAPIKey) {
-        return Promise.resolve(runtimeProvisionedAPIKey);
-      }
-      if (!configuredProvisionToken) {
-        return Promise.reject(
-          new Error("mem9 create-new setup cannot provision because provisionToken is missing"),
-        );
-      }
+    const resolveAPIKey = (agentName: string): Promise<string> => {
+      if (configuredApiKey) return Promise.resolve(configuredApiKey);
       if (!registrationPromise) {
-        registrationPromise = resolveSharedProvisionedAPIKey(
-          effectiveApiUrl,
-          provisionQueryParams,
-          configuredProvisionToken,
-          timeoutConfig,
-          api.logger,
-          () => registerTenant(agentName),
-        )
-          .then((apiKey) => {
-            runtimeProvisionedAPIKey = apiKey;
-            return apiKey;
-          })
-          .catch((err) => {
-            registrationPromise = null;
-            throw err;
-          });
+        registrationPromise = registerTenant(agentName);
       }
       return registrationPromise;
     };
-    const resolveAPIKey = async (): Promise<string> => {
-      if (configuredApiKey) return Promise.resolve(configuredApiKey);
-      if (runtimeProvisionedAPIKey) {
-        return runtimeProvisionedAPIKey;
-      }
-      if (configuredProvisionToken) {
-        const sharedKey = sharedProvisionKey(
-          effectiveApiUrl,
-          provisionQueryParams,
-          configuredProvisionToken,
-        );
-        const sharedApiKey = await waitForSharedProvisionResult(
-          sharedProvisionStatePath(sharedKey),
-          provisionWaitTimeoutMs,
-        );
-        if (sharedApiKey) {
-          runtimeProvisionedAPIKey = sharedApiKey;
-          if (!loggedPersistedProvisionedAPIKeyReuse) {
-            api.logger.info("[mem9] reusing locally persisted create-new API key for this provisionToken");
-            loggedPersistedProvisionedAPIKeyReuse = true;
-          }
-          return sharedApiKey;
-        }
-      }
-      throw new PendingProvisionError();
-    };
 
     api.logger.info("[mem9] Server mode (v1alpha2)");
-    if (!configuredApiKey) {
-      if (configuredProvisionToken) {
-        api.logger.info(
-          "[mem9] apiKey not configured; waiting for the first post-restart message to finish create-new provision",
-        );
-      } else {
-        api.logger.info("[mem9] apiKey not configured; mem9 will stay idle until apiKey is configured");
-      }
-    }
+
+    const hookAgentId = cfg.agentName ?? "agent";
 
     const factory: ToolFactory = (ctx: ToolContext) => {
       const agentId = ctx.agentId ?? cfg.agentName ?? "agent";
       const backend = new LazyServerBackend(
         effectiveApiUrl,
-        resolveAPIKey,
+        () => resolveAPIKey(agentId),
         agentId,
         timeoutConfig,
       );
@@ -677,25 +350,11 @@ const mnemoPlugin = {
     // Shared lazy backend for hooks and capability registration.
     const hookBackend = new LazyServerBackend(
       effectiveApiUrl,
-      resolveAPIKey,
+      () => resolveAPIKey(hookAgentId),
       hookAgentId,
       timeoutConfig,
     );
 
-    const withPendingProvisionFallback = async <T>(
-      action: () => Promise<T>,
-      fallback: T,
-    ): Promise<T> => {
-      try {
-        return await action();
-      } catch (err) {
-        if (isPendingProvisionError(err)) {
-          return fallback;
-        }
-        throw err;
-      }
-    };
-
     // 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.
@@ -703,24 +362,14 @@ const mnemoPlugin = {
     if (typeof api.registerCapability === "function") {
       api.registerCapability("memory", {
         search: async (query, opts) => {
-          const result = await withPendingProvisionFallback(
-            () => hookBackend.search({ q: query, limit: opts?.limit }),
-            { data: [], total: 0, limit: opts?.limit ?? 20, offset: 0 },
-          );
+          const result = await hookBackend.search({ q: query, limit: opts?.limit });
           return { data: result.data, total: result.total };
         },
         store: async (content, opts) => {
-          try {
-            return await hookBackend.store({ content, tags: opts?.tags, source: opts?.source });
-          } catch (err) {
-            if (isPendingProvisionError(err)) {
-              return null;
-            }
-            throw err;
-          }
+          return hookBackend.store({ content, tags: opts?.tags, source: opts?.source });
         },
-        get: (id) => withPendingProvisionFallback(() => hookBackend.get(id), null),
-        remove: (id) => withPendingProvisionFallback(() => hookBackend.remove(id), false),
+        get: (id) => hookBackend.get(id),
+        remove: (id) => hookBackend.remove(id),
       });
     }
 
@@ -728,9 +377,6 @@ const mnemoPlugin = {
     registerHooks(api, hookBackend, api.logger, {
       maxIngestBytes: cfg.maxIngestBytes,
       fallbackAgentId: hookAgentId,
-      provisionForCreateNew: configuredApiKey || !configuredProvisionToken
-        ? undefined
-        : () => provisionAPIKey(hookAgentId),
     });
   },
 };
@@ -744,24 +390,15 @@ const toolNames = [
 ];
 
 class LazyServerBackend implements MemoryBackend {
-  private apiUrl: string;
-  private apiKeyProvider: () => Promise<string>;
-  private agentId: string;
-  private timeouts: BackendTimeouts;
   private resolved: ServerBackend | null = null;
   private resolving: Promise<ServerBackend> | null = null;
 
   constructor(
-    apiUrl: string,
-    apiKeyProvider: () => Promise<string>,
-    agentId: string,
-    timeouts: BackendTimeouts,
-  ) {
-    this.apiUrl = apiUrl;
-    this.apiKeyProvider = apiKeyProvider;
-    this.agentId = agentId;
-    this.timeouts = timeouts;
-  }
+    private apiUrl: string,
+    private apiKeyProvider: () => Promise<string>,
+    private agentId: string,
+    private timeouts: BackendTimeouts,
+  ) {}
 
   private async resolve(): Promise<ServerBackend> {
     if (this.resolved) return this.resolved;
@@ -769,9 +406,7 @@ class LazyServerBackend implements MemoryBackend {
 
     this.resolving = this.apiKeyProvider().then((apiKey) =>
       Promise.resolve().then(() => {
-        this.resolved = new ServerBackend(this.apiUrl, apiKey, this.agentId, {
-          timeouts: this.timeouts,
-        });
+        this.resolved = new ServerBackend(this.apiUrl, apiKey, this.agentId, this.timeouts);
         return this.resolved;
       })
     ).catch((err) => {

package/openclaw.plugin.json

@@ -14,17 +14,6 @@
         "type": "string",
         "description": "mem9 API key (secret — do not share)"
       },
-      "provisionToken": {
-        "type": "string",
-        "description": "One-time create-new token used locally to ensure first-message API-key provisioning runs only once and can be reused on this machine before apiKey is configured explicitly"
-      },
-      "provisionQueryParams": {
-        "type": "object",
-        "description": "Optional utm_* params forwarded only by the first create-new provision request triggered after the initial restart",
-        "additionalProperties": {
-          "type": "string"
-        }
-      },
       "defaultTimeoutMs": {
         "type": "number",
         "minimum": 1,
@@ -51,10 +40,6 @@
       "placeholder": "key...",
       "sensitive": true
     },
-    "provisionToken": {
-      "label": "Provision Token",
-      "placeholder": "create-new only"
-    },
     "defaultTimeoutMs": {
       "label": "Default Timeout (ms)",
       "placeholder": "8000"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mem9/mem9",
-  "version": "0.4.6",
+  "version": "0.4.7",
   "description": "OpenClaw shared memory plugin — cloud-persistent memory with hybrid vector + keyword search via mnemo-server",
   "type": "module",
   "license": "Apache-2.0",
@@ -34,7 +34,6 @@
     "access": "public"
   },
   "scripts": {
-    "test": "rm -rf ./dist-test && tsc -p ./tsconfig.test.json && node --test ./dist-test/*.test.js",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run typecheck"
   },
@@ -43,7 +42,6 @@
   },
   "dependencies": {},
   "devDependencies": {
-    "@types/node": "^22.15.30",
     "typescript": "^5.5.0"
   },
   "openclaw": {

package/server-backend.ts

@@ -22,11 +22,6 @@ export interface BackendTimeouts {
   searchTimeoutMs?: number;
 }
 
-interface ServerBackendOptions {
-  timeouts?: BackendTimeouts;
-  provisionQueryParams?: Record<string, string>;
-}
-
 interface RequestOptions {
   timeoutMs?: number;
 }
@@ -35,37 +30,25 @@ export class ServerBackend implements MemoryBackend {
   private baseUrl: string;
   private apiKey: string;
   private agentName: string;
-  private provisionQueryParams: Record<string, string>;
   private timeouts: Required<BackendTimeouts>;
 
   constructor(
     apiUrl: string,
     apiKey: string,
     agentName: string,
-    options: ServerBackendOptions = {},
+    timeouts: BackendTimeouts = {},
   ) {
     this.baseUrl = apiUrl.replace(/\/+$/, "");
     this.apiKey = apiKey;
     this.agentName = agentName;
-    this.provisionQueryParams = options.provisionQueryParams ?? {};
     this.timeouts = {
-      defaultTimeoutMs: options.timeouts?.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS,
-      searchTimeoutMs: options.timeouts?.searchTimeoutMs ?? DEFAULT_SEARCH_TIMEOUT_MS,
+      defaultTimeoutMs: timeouts.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS,
+      searchTimeoutMs: timeouts.searchTimeoutMs ?? DEFAULT_SEARCH_TIMEOUT_MS,
     };
   }
 
   async register(): Promise<ProvisionMem9sResponse> {
-    const query = new URLSearchParams();
-    for (const [key, value] of Object.entries(this.provisionQueryParams)) {
-      if (!key.startsWith("utm_") || typeof value !== "string" || value === "") {
-        continue;
-      }
-
-      query.set(key, value);
-    }
-
-    const qs = query.toString();
-    const resp = await fetch(this.baseUrl + "/v1alpha1/mem9s" + (qs ? `?${qs}` : ""), {
+    const resp = await fetch(this.baseUrl + "/v1alpha1/mem9s", {
       method: "POST",
       signal: AbortSignal.timeout(this.timeouts.defaultTimeoutMs),
     });

package/types.ts

@@ -2,8 +2,6 @@ export interface PluginConfig {
   // Server mode (apiUrl present → server)
   apiUrl?: string;
   apiKey?: string;
-  provisionToken?: string;
-  provisionQueryParams?: Record<string, string>;
   tenantID?: string;
   defaultTimeoutMs?: number;
   searchTimeoutMs?: number;

package/index.test.ts

@@ -1,393 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import mnemoPlugin from "./index.js";
-
-interface RegisteredTool {
-  name: string;
-  execute: (_id: string, params: unknown) => Promise<unknown>;
-}
-
-interface SearchCapability {
-  search: (query: string, opts?: { limit?: number }) => Promise<{ data: unknown[]; total: number }>;
-}
-
-type HookHandler = (...args: unknown[]) => unknown;
-
-interface StubApi {
-  pluginConfig?: unknown;
-  logger: {
-    info: (...args: unknown[]) => void;
-    error: (...args: unknown[]) => void;
-  };
-  registerTool: (factory: unknown, _opts?: unknown) => void;
-  registerCapability?: (slot: string, capability: unknown) => void;
-  on: (...args: unknown[]) => void;
-  getTools: (ctx?: { agentId?: string }) => RegisteredTool[];
-  getHook: (name: string) => HookHandler;
-}
-
-function createStubApi(
-  pluginConfig: unknown,
-  options?: {
-    onRegisterCapability?: (slot: string, capability: unknown) => void;
-    infoLogs?: string[];
-    errorLogs?: string[];
-  },
-): StubApi {
-  const infoLogs = options?.infoLogs ?? [];
-  const errorLogs = options?.errorLogs ?? [];
-  const hooks = new Map<string, HookHandler>();
-  let toolFactory:
-    | ((ctx?: { agentId?: string }) => RegisteredTool[] | RegisteredTool | null | undefined)
-    | null = null;
-
-  return {
-    pluginConfig,
-    logger: {
-      info: (...args: unknown[]) => {
-        infoLogs.push(args.map(String).join(" "));
-      },
-      error: (...args: unknown[]) => {
-        errorLogs.push(args.map(String).join(" "));
-      },
-    },
-    registerTool: (factory: unknown) => {
-      toolFactory = factory as typeof toolFactory;
-    },
-    registerCapability: options?.onRegisterCapability,
-    on: (hookName: unknown, handler: unknown) => {
-      if (typeof hookName === "string" && typeof handler === "function") {
-        hooks.set(hookName, handler as HookHandler);
-      }
-    },
-    getTools: (ctx = {}) => {
-      if (!toolFactory) {
-        return [];
-      }
-      const tools = toolFactory(ctx);
-      if (!tools) {
-        return [];
-      }
-      return Array.isArray(tools) ? tools : [tools];
-    },
-    getHook: (name: string) => {
-      const hook = hooks.get(name);
-      if (!hook) {
-        throw new Error(`missing hook: ${name}`);
-      }
-      return hook;
-    },
-  };
-}
-
-async function flushAsyncWork(): Promise<void> {
-  await new Promise((resolve) => setTimeout(resolve, 0));
-}
-
-async function waitFor(predicate: () => boolean, timeoutMs = 2_000): Promise<void> {
-  const startedAt = Date.now();
-
-  while (!predicate()) {
-    if (Date.now() - startedAt > timeoutMs) {
-      throw new Error("timed out waiting for condition");
-    }
-    await new Promise((resolve) => setTimeout(resolve, 10));
-  }
-}
-
-function uniqueApiUrl(name: string): string {
-  return `https://api.mem9.ai/${name}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-}
-
-test("register does not auto-provision on startup during create-new", async () => {
-  const originalFetch = globalThis.fetch;
-  const apiUrl = uniqueApiUrl("no-startup-provision");
-  const requests: string[] = [];
-  const infoLogs: string[] = [];
-  const errorLogs: string[] = [];
-
-  globalThis.fetch = async (input) => {
-    requests.push(String(input));
-    throw new Error("unexpected fetch");
-  };
-
-  try {
-    mnemoPlugin.register(
-      createStubApi(
-        {
-          apiUrl,
-          provisionToken: "token-startup",
-          provisionQueryParams: {
-            utm_source: "bosn",
-          },
-        },
-        { infoLogs, errorLogs },
-      ),
-    );
-
-    await flushAsyncWork();
-
-    assert.deepEqual(requests, []);
-    assert.deepEqual(errorLogs, []);
-    assert.equal(
-      infoLogs.includes(
-        "[mem9] apiKey not configured; waiting for the first post-restart message to finish create-new provision",
-      ),
-      true,
-    );
-  } finally {
-    globalThis.fetch = originalFetch;
-  }
-});
-
-test("memory capability stays idle until explicit provision runs", async () => {
-  const originalFetch = globalThis.fetch;
-  const apiUrl = uniqueApiUrl("pending-capability");
-  let capability: SearchCapability | null = null;
-  const requests: string[] = [];
-
-  globalThis.fetch = async (input) => {
-    requests.push(String(input));
-    throw new Error("unexpected fetch");
-  };
-
-  try {
-    mnemoPlugin.register(
-      createStubApi(
-        {
-          apiUrl,
-          provisionToken: "token-capability",
-        },
-        {
-          onRegisterCapability: (_slot, registeredCapability) => {
-            capability = registeredCapability as SearchCapability;
-          },
-        },
-      ),
-    );
-
-    assert.notEqual(capability, null);
-
-    const result = await capability!.search("hello");
-
-    assert.deepEqual(result, { data: [], total: 0 });
-    assert.deepEqual(requests, []);
-  } finally {
-    globalThis.fetch = originalFetch;
-  }
-});
-
-test("first post-restart prompt provisions once and unlocks memory access", async () => {
-  const originalFetch = globalThis.fetch;
-  const apiUrl = uniqueApiUrl("explicit-provision");
-  let capability: SearchCapability | null = null;
-  let provisionRequests = 0;
-  let searchRequests = 0;
-
-  globalThis.fetch = async (input, init) => {
-    const url = String(input);
-
-    if (url === `${apiUrl}/v1alpha1/mem9s?utm_source=bosn`) {
-      provisionRequests += 1;
-      return new Response(JSON.stringify({ id: "space-explicit" }), {
-        status: 201,
-        headers: {
-          "Content-Type": "application/json",
-        },
-      });
-    }
-
-    if (url.includes("/v1alpha2/mem9s/memories")) {
-      searchRequests += 1;
-      const headers = init?.headers as Record<string, string> | undefined;
-      assert.equal(headers?.["X-API-Key"], "space-explicit");
-
-      return new Response(
-        JSON.stringify({
-          memories: [],
-          total: 0,
-          limit: 20,
-          offset: 0,
-        }),
-        {
-          status: 200,
-          headers: {
-            "Content-Type": "application/json",
-          },
-        },
-      );
-    }
-
-    throw new Error(`unexpected fetch: ${url}`);
-  };
-
-    try {
-      const api = createStubApi(
-      {
-        apiUrl,
-        provisionToken: "token-explicit",
-        provisionQueryParams: {
-          utm_source: "bosn",
-        },
-      },
-      {
-        onRegisterCapability: (_slot, registeredCapability) => {
-          capability = registeredCapability as SearchCapability;
-        },
-      },
-    );
-    mnemoPlugin.register(api);
-
-    const beforePromptBuild = api.getHook("before_prompt_build");
-    const hookResult = await beforePromptBuild({ prompt: "hi" });
-
-    assert.equal(hookResult, undefined);
-    assert.equal(provisionRequests, 1);
-
-    assert.notEqual(capability, null);
-    const searchResult = await capability!.search("hello");
-
-    assert.deepEqual(searchResult, { data: [], total: 0 });
-    assert.equal(provisionRequests, 1);
-    assert.equal(searchRequests, 1);
-  } finally {
-    globalThis.fetch = originalFetch;
-  }
-});
-
-test("concurrent first-post-restart prompts share one server request", async () => {
-  const originalFetch = globalThis.fetch;
-  const apiUrl = uniqueApiUrl("shared-explicit");
-  let provisionRequests = 0;
-  const provisionControl: { release: () => void } = {
-    release: () => {},
-  };
-  const provisionGate = new Promise<void>((resolve) => {
-    provisionControl.release = resolve;
-  });
-
-  globalThis.fetch = async (input) => {
-    const url = String(input);
-
-    if (url === `${apiUrl}/v1alpha1/mem9s`) {
-      provisionRequests += 1;
-      await provisionGate;
-      return new Response(JSON.stringify({ id: "space-shared-explicit" }), {
-        status: 201,
-        headers: {
-          "Content-Type": "application/json",
-        },
-      });
-    }
-
-    throw new Error(`unexpected fetch: ${url}`);
-  };
-
-  try {
-    const pluginConfig = {
-      apiUrl,
-      provisionToken: "token-shared-explicit",
-    };
-    const apiA = createStubApi(pluginConfig);
-    const apiB = createStubApi(pluginConfig);
-
-    mnemoPlugin.register(apiA);
-    mnemoPlugin.register(apiB);
-
-    const hookA = apiA.getHook("before_prompt_build");
-    const hookB = apiB.getHook("before_prompt_build");
-
-    const promiseA = hookA({ prompt: "hi" });
-    const promiseB = hookB({ prompt: "hi" });
-
-    await waitFor(() => provisionRequests === 1);
-    provisionControl.release();
-
-    await promiseA;
-    await promiseB;
-
-    assert.equal(provisionRequests, 1);
-  } finally {
-    provisionControl.release();
-    globalThis.fetch = originalFetch;
-  }
-});
-
-test("a second setup retry reuses the locally persisted provisioned key before config write-back", async () => {
-  const originalFetch = globalThis.fetch;
-  const apiUrl = uniqueApiUrl("shared-retry");
-  const infoLogsA: string[] = [];
-  const infoLogsB: string[] = [];
-  let provisionRequests = 0;
-  let searchRequests = 0;
-
-  globalThis.fetch = async (input, init) => {
-    const url = String(input);
-
-    if (url === `${apiUrl}/v1alpha1/mem9s`) {
-      provisionRequests += 1;
-      return new Response(JSON.stringify({ id: "space-shared-retry" }), {
-        status: 201,
-        headers: {
-          "Content-Type": "application/json",
-        },
-      });
-    }
-
-    if (url.includes("/v1alpha2/mem9s/memories")) {
-      searchRequests += 1;
-      const headers = init?.headers as Record<string, string> | undefined;
-      assert.equal(headers?.["X-API-Key"], "space-shared-retry");
-      return new Response(
-        JSON.stringify({
-          memories: [],
-          total: 0,
-          limit: 20,
-          offset: 0,
-        }),
-        {
-          status: 200,
-          headers: {
-            "Content-Type": "application/json",
-          },
-        },
-      );
-    }
-
-    throw new Error(`unexpected fetch: ${url}`);
-  };
-
-  try {
-    const pluginConfig = {
-      apiUrl,
-      provisionToken: "token-shared-retry",
-    };
-
-    const apiA = createStubApi(pluginConfig, { infoLogs: infoLogsA });
-    mnemoPlugin.register(apiA);
-    const firstHook = apiA.getHook("before_prompt_build");
-    await firstHook({ prompt: "hi" });
-
-    let capabilityB: SearchCapability | null = null;
-    const apiB = createStubApi(pluginConfig, {
-      infoLogs: infoLogsB,
-      onRegisterCapability: (_slot, registeredCapability) => {
-        capabilityB = registeredCapability as SearchCapability;
-      },
-    });
-    mnemoPlugin.register(apiB);
-    assert.notEqual(capabilityB, null);
-    const secondResult = await capabilityB!.search("hello");
-
-    assert.equal(provisionRequests, 1);
-    assert.deepEqual(secondResult, { data: [], total: 0 });
-    assert.equal(searchRequests, 1);
-    assert.equal(
-      infoLogsB.includes("[mem9] reusing locally persisted create-new API key for this provisionToken"),
-      true,
-    );
-  } finally {
-    globalThis.fetch = originalFetch;
-  }
-});

package/server-backend.test.ts

@@ -1,82 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { ServerBackend } from "./server-backend.js";
-
-test("register forwards only utm_* params during create-new provision", async () => {
-  const originalFetch = globalThis.fetch;
-  let requestedURL = "";
-
-  globalThis.fetch = async (input, init) => {
-    requestedURL = String(input);
-    assert.equal(init?.method, "POST");
-
-    return new Response(JSON.stringify({ id: "space-1" }), {
-      status: 201,
-      headers: {
-        "Content-Type": "application/json",
-      },
-    });
-  };
-
-  try {
-    const backend = new ServerBackend("https://api.mem9.ai", "", "agent-1", {
-      provisionQueryParams: {
-        utm_source: "bosn",
-        foo: "bar",
-        utm_campaign: "spring",
-        utm_medium: "",
-      },
-    });
-
-    const result = await backend.register();
-    assert.equal(result.id, "space-1");
-
-    const url = new URL(requestedURL);
-    assert.equal(url.origin + url.pathname, "https://api.mem9.ai/v1alpha1/mem9s");
-    assert.equal(url.searchParams.get("utm_source"), "bosn");
-    assert.equal(url.searchParams.get("utm_campaign"), "spring");
-    assert.equal(url.searchParams.has("foo"), false);
-    assert.equal(url.searchParams.has("utm_medium"), false);
-  } finally {
-    globalThis.fetch = originalFetch;
-  }
-});
-
-test("normal memory requests do not append provision query params", async () => {
-  const originalFetch = globalThis.fetch;
-  let requestedURL = "";
-
-  globalThis.fetch = async (input) => {
-    requestedURL = String(input);
-
-    return new Response(
-      JSON.stringify({
-        id: "mem-1",
-        content: "remember this",
-        created_at: "2026-04-05T00:00:00Z",
-        updated_at: "2026-04-05T00:00:00Z",
-      }),
-      {
-        status: 200,
-        headers: {
-          "Content-Type": "application/json",
-        },
-      },
-    );
-  };
-
-  try {
-    const backend = new ServerBackend("https://api.mem9.ai", "space-key", "agent-1", {
-      provisionQueryParams: {
-        utm_source: "bosn",
-      },
-    });
-
-    await backend.store({ content: "remember this" });
-
-    assert.equal(requestedURL, "https://api.mem9.ai/v1alpha2/mem9s/memories");
-  } finally {
-    globalThis.fetch = originalFetch;
-  }
-});