@mem9/mem9 0.4.0 → 0.4.2

package/index.test.ts

@@ -0,0 +1,193 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import mnemoPlugin from "./index.js";
+
+interface StubApi {
+  pluginConfig?: unknown;
+  logger: {
+    info: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+  };
+  registerTool: () => void;
+  registerCapability?: (slot: string, capability: unknown) => void;
+  on: () => void;
+}
+
+function createStubApi(
+  pluginConfig: unknown,
+  options?: {
+    onRegisterCapability?: (slot: string, capability: unknown) => void;
+    infoLogs?: string[];
+    errorLogs?: string[];
+  },
+): StubApi {
+  const infoLogs = options?.infoLogs ?? [];
+  const errorLogs = options?.errorLogs ?? [];
+
+  return {
+    pluginConfig,
+    logger: {
+      info: (...args: unknown[]) => {
+        infoLogs.push(args.map(String).join(" "));
+      },
+      error: (...args: unknown[]) => {
+        errorLogs.push(args.map(String).join(" "));
+      },
+    },
+    registerTool: () => {},
+    registerCapability: options?.onRegisterCapability,
+    on: () => {},
+  };
+}
+
+async function flushAsyncWork(): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+test("register eagerly auto-provisions when apiKey is absent", async () => {
+  const originalFetch = globalThis.fetch;
+  const requests: string[] = [];
+  const infoLogs: string[] = [];
+  const errorLogs: string[] = [];
+
+  globalThis.fetch = async (input) => {
+    requests.push(String(input));
+
+    return new Response(JSON.stringify({ id: "space-1" }), {
+      status: 201,
+      headers: {
+        "Content-Type": "application/json",
+      },
+    });
+  };
+
+  try {
+    mnemoPlugin.register(
+      createStubApi(
+        {
+          apiUrl: "https://api.mem9.ai",
+          provisionQueryParams: {
+            utm_source: "bosn",
+          },
+        },
+        { infoLogs, errorLogs },
+      ),
+    );
+
+    await flushAsyncWork();
+
+    assert.deepEqual(errorLogs, []);
+    assert.equal(requests.length, 1);
+    assert.equal(
+      requests[0],
+      "https://api.mem9.ai/v1alpha1/mem9s?utm_source=bosn",
+    );
+    assert.equal(
+      infoLogs.includes("[mem9] apiKey not configured; starting auto-provision"),
+      true,
+    );
+    assert.equal(
+      infoLogs.some((msg) => msg.includes("*** Auto-provisioned apiKey=space-1 ***")),
+      true,
+    );
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test("search retries auto-provision after an eager startup failure", async () => {
+  const originalFetch = globalThis.fetch;
+  const infoLogs: string[] = [];
+  const errorLogs: string[] = [];
+  let provisionAttempts = 0;
+  let searchRequests = 0;
+  let capability: {
+    search: (query: string, opts?: { limit?: number }) => Promise<{ data: unknown[]; total: number }>;
+  } | null = null;
+
+  globalThis.fetch = async (input, init) => {
+    const url = String(input);
+
+    if (url.includes("/v1alpha1/mem9s")) {
+      provisionAttempts += 1;
+
+      if (provisionAttempts === 1) {
+        return new Response(JSON.stringify({ error: "boom" }), {
+          status: 500,
+          headers: {
+            "Content-Type": "application/json",
+          },
+        });
+      }
+
+      return new Response(JSON.stringify({ id: "space-2" }), {
+        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-2");
+
+      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 {
+    mnemoPlugin.register(
+      createStubApi(
+        {
+          apiUrl: "https://api.mem9.ai",
+        },
+        {
+          infoLogs,
+          errorLogs,
+          onRegisterCapability: (_slot, registeredCapability) => {
+            capability = registeredCapability as typeof capability;
+          },
+        },
+      ),
+    );
+
+    await flushAsyncWork();
+
+    assert.equal(provisionAttempts, 1);
+    assert.equal(
+      errorLogs.some((msg) => msg.includes("auto-provision failed: mem9s provision failed (500):")),
+      true,
+    );
+    assert.notEqual(capability, null);
+
+    const result = await capability!.search("hello");
+
+    assert.deepEqual(result, { data: [], total: 0 });
+    assert.equal(provisionAttempts, 2);
+    assert.equal(searchRequests, 1);
+    assert.equal(
+      infoLogs.some((msg) => msg.includes("*** Auto-provisioned apiKey=space-2 ***")),
+      true,
+    );
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});

package/index.ts

@@ -75,6 +75,10 @@ function jsonResult(data: unknown) {
   }
 }
 
+function errorMessage(err: unknown): string {
+  return err instanceof Error ? err.message : String(err);
+}
+
 interface MemoryCapability {
   search: (query: string, opts?: { limit?: number }) => Promise<{ data: Memory[]; total: number }>;
   store: (content: string, opts?: { tags?: string[]; source?: string }) => Promise<unknown>;
@@ -303,6 +307,7 @@ const mnemoPlugin = {
     const cfg = (api.pluginConfig ?? {}) as PluginConfig;
     const effectiveApiUrl = cfg.apiUrl ?? DEFAULT_API_URL;
     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}`);
     }
@@ -333,14 +338,22 @@ const mnemoPlugin = {
     const resolveAPIKey = (agentName: string): Promise<string> => {
       if (configuredApiKey) return Promise.resolve(configuredApiKey);
       if (!registrationPromise) {
-        registrationPromise = registerTenant(agentName);
+        registrationPromise = registerTenant(agentName).catch((err) => {
+          registrationPromise = null;
+          throw err;
+        });
       }
       return registrationPromise;
     };
 
     api.logger.info("[mem9] Server mode (v1alpha2)");
 
-    const hookAgentId = cfg.agentName ?? "agent";
+    if (!configuredApiKey) {
+      api.logger.info("[mem9] apiKey not configured; starting auto-provision");
+      void resolveAPIKey(hookAgentId).catch((err) => {
+        api.logger.error(`[mem9] auto-provision failed: ${errorMessage(err)}`);
+      });
+    }
 
     const factory: ToolFactory = (ctx: ToolContext) => {
       const agentId = ctx.agentId ?? cfg.agentName ?? "agent";
@@ -398,15 +411,24 @@ 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(
-    private apiUrl: string,
-    private apiKeyProvider: () => Promise<string>,
-    private agentId: string,
-    private timeouts: BackendTimeouts,
-  ) {}
+    apiUrl: string,
+    apiKeyProvider: () => Promise<string>,
+    agentId: string,
+    timeouts: BackendTimeouts,
+  ) {
+    this.apiUrl = apiUrl;
+    this.apiKeyProvider = apiKeyProvider;
+    this.agentId = agentId;
+    this.timeouts = timeouts;
+  }
 
   private async resolve(): Promise<ServerBackend> {
     if (this.resolved) return this.resolved;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mem9/mem9",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "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,7 @@
     "access": "public"
   },
   "scripts": {
-    "test": "node --experimental-strip-types --test ./server-backend.test.ts",
+    "test": "rm -rf ./dist-test && tsc -p ./tsconfig.test.json && node --test ./dist-test/*.test.js",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run typecheck"
   },

package/server-backend.test.ts

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { ServerBackend } from "./server-backend.ts";
+import { ServerBackend } from "./server-backend.js";
 
 test("register forwards only utm_* params during auto-provision", async () => {
   const originalFetch = globalThis.fetch;