memorylake-openclaw 0.0.6 → 0.0.7

package/index.ts

@@ -10,6 +10,8 @@
  * - CLI: openclaw memorylake search, openclaw memorylake stats
  */
 
+import fs from "node:fs";
+import path from "node:path";
 import got from "got";
 import { Type } from "@sinclair/typebox";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
@@ -530,6 +532,52 @@ const memoryPlugin = {
     const cfg = memoryLakeConfigSchema.parse(api.pluginConfig);
     const provider: MemoryLakeProvider = new PlatformProvider(cfg.host, cfg.apiKey, cfg.projectId);
 
+    // Provider cache: avoids re-creating providers for the same host+apiKey+projectId
+    const providerCache = new Map<string, MemoryLakeProvider>();
+    const globalProviderKey = `${cfg.host}|${cfg.apiKey}|${cfg.projectId}`;
+    providerCache.set(globalProviderKey, provider);
+
+    function getProvider(effectiveCfg: MemoryLakeConfig): MemoryLakeProvider {
+      const key = `${effectiveCfg.host}|${effectiveCfg.apiKey}|${effectiveCfg.projectId}`;
+      let p = providerCache.get(key);
+      if (!p) {
+        p = new PlatformProvider(effectiveCfg.host, effectiveCfg.apiKey, effectiveCfg.projectId);
+        providerCache.set(key, p);
+      }
+      return p;
+    }
+
+    function resolveConfig(ctx: any): MemoryLakeConfig {
+      const workspaceDir = ctx?.workspaceDir;
+      if (!workspaceDir) return cfg;
+
+      const localPath = path.join(workspaceDir, ".memorylake", "config.json");
+      if (!fs.existsSync(localPath)) return cfg;
+
+      try {
+        const raw = JSON.parse(fs.readFileSync(localPath, "utf-8"));
+        if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+          api.logger.warn(
+            `memorylake-openclaw: workspace config exists but is not a JSON object; falling back to global config (path: ${localPath})`,
+          );
+          return cfg;
+        }
+
+        const allowed = new Set(ALLOWED_KEYS);
+        const overrides: Record<string, unknown> = {};
+        for (const [key, value] of Object.entries(raw)) {
+          if (allowed.has(key)) overrides[key] = value;
+        }
+
+        return { ...cfg, ...overrides } as MemoryLakeConfig;
+      } catch {
+        api.logger.warn(
+          `memorylake-openclaw: failed to parse workspace config JSON; falling back to global config (path: ${localPath})`,
+        );
+        return cfg;
+      }
+    }
+
     // Track current session ID for tool-level session scoping
     let currentSessionId: string | undefined;
 
@@ -538,9 +586,9 @@ const memoryPlugin = {
     );
 
     // Helper: build add options
-    function buildAddOptions(userIdOverride?: string, sessionId?: string): AddOptions {
+    function buildAddOptions(effectiveCfg: MemoryLakeConfig, userIdOverride?: string, sessionId?: string): AddOptions {
       const opts: AddOptions = {
-        user_id: userIdOverride || cfg.userId,
+        user_id: userIdOverride || effectiveCfg.userId,
         infer: true,
         metadata: { source: "OPENCLAW" },
       };
@@ -550,14 +598,15 @@ const memoryPlugin = {
 
     // Helper: build search options
     function buildSearchOptions(
+      effectiveCfg: MemoryLakeConfig,
       userIdOverride?: string,
       limit?: number,
     ): SearchOptions {
       return {
-        user_id: userIdOverride || cfg.userId,
-        top_k: limit ?? cfg.topK,
-        threshold: cfg.searchThreshold,
-        rerank: cfg.rerank,
+        user_id: userIdOverride || effectiveCfg.userId,
+        top_k: limit ?? effectiveCfg.topK,
+        threshold: effectiveCfg.searchThreshold,
+        rerank: effectiveCfg.rerank,
       };
     }
 
@@ -566,7 +615,7 @@ const memoryPlugin = {
     // ========================================================================
 
     api.registerTool(
-      {
+      (ctx) => ({
         name: "memory_search",
         label: "Memory Search",
         description:
@@ -596,6 +645,8 @@ const memoryPlugin = {
           ),
         }),
         async execute(_toolCallId, params) {
+          const effectiveCfg = resolveConfig(ctx);
+          const effectiveProvider = getProvider(effectiveCfg);
           const { query, limit, userId, scope = "all" } = params as {
             query: string;
             limit?: number;
@@ -604,9 +655,9 @@ const memoryPlugin = {
           };
 
           try {
-            const results = await provider.search(
+            const results = await effectiveProvider.search(
               query,
-              buildSearchOptions(userId, limit),
+              buildSearchOptions(effectiveCfg, userId, limit),
             );
 
             if (!results || results.length === 0) {
@@ -652,12 +703,12 @@ const memoryPlugin = {
             };
           }
         },
-      },
+      }),
       { name: "memory_search" },
     );
 
     api.registerTool(
-      {
+      (ctx) => ({
         name: "memory_store",
         label: "Memory Store",
         description:
@@ -676,6 +727,8 @@ const memoryPlugin = {
           ),
         }),
         async execute(_toolCallId, params) {
+          const effectiveCfg = resolveConfig(ctx);
+          const effectiveProvider = getProvider(effectiveCfg);
           const { text, userId } = params as {
             text: string;
             userId?: string;
@@ -683,9 +736,9 @@ const memoryPlugin = {
           };
 
           try {
-            const result = await provider.add(
+            const result = await effectiveProvider.add(
               [{ role: "user", content: text }],
-              buildAddOptions(userId, currentSessionId),
+              buildAddOptions(effectiveCfg, userId, currentSessionId),
             );
 
             const count = result.results?.length ?? 0;
@@ -716,12 +769,12 @@ const memoryPlugin = {
             };
           }
         },
-      },
+      }),
       { name: "memory_store" },
     );
 
     api.registerTool(
-      {
+      (ctx) => ({
         name: "memory_get",
         label: "Memory Get",
         description: "Retrieve a specific memory by its ID from MemoryLake.",
@@ -729,10 +782,12 @@ const memoryPlugin = {
           memoryId: Type.String({ description: "The memory ID to retrieve" }),
         }),
         async execute(_toolCallId, params) {
+          const effectiveCfg = resolveConfig(ctx);
+          const effectiveProvider = getProvider(effectiveCfg);
           const { memoryId } = params as { memoryId: string };
 
           try {
-            const memory = await provider.get(memoryId);
+            const memory = await effectiveProvider.get(memoryId);
 
             return {
               content: [
@@ -755,12 +810,12 @@ const memoryPlugin = {
             };
           }
         },
-      },
+      }),
       { name: "memory_get" },
     );
 
     api.registerTool(
-      {
+      (ctx) => ({
         name: "memory_list",
         label: "Memory List",
         description:
@@ -784,11 +839,13 @@ const memoryPlugin = {
           ),
         }),
         async execute(_toolCallId, params) {
+          const effectiveCfg = resolveConfig(ctx);
+          const effectiveProvider = getProvider(effectiveCfg);
           const { userId, scope = "all" } = params as { userId?: string; scope?: "session" | "long-term" | "all" };
 
           try {
-            const uid = userId || cfg.userId;
-            const memories = await provider.getAll({ user_id: uid });
+            const uid = userId || effectiveCfg.userId;
+            const memories = await effectiveProvider.getAll({ user_id: uid });
 
             if (!memories || memories.length === 0) {
               return {
@@ -833,12 +890,12 @@ const memoryPlugin = {
             };
           }
         },
-      },
+      }),
       { name: "memory_list" },
     );
 
     api.registerTool(
-      {
+      (ctx) => ({
         name: "memory_forget",
         label: "Memory Forget",
         description:
@@ -847,10 +904,12 @@ const memoryPlugin = {
           memoryId: Type.String({ description: "Memory ID to delete" }),
         }),
         async execute(_toolCallId, params) {
+          const effectiveCfg = resolveConfig(ctx);
+          const effectiveProvider = getProvider(effectiveCfg);
           const { memoryId } = params as { memoryId: string };
 
           try {
-            await provider.delete(memoryId);
+            await effectiveProvider.delete(memoryId);
             return {
               content: [
                 { type: "text", text: `Memory ${memoryId} forgotten.` },
@@ -869,12 +928,12 @@ const memoryPlugin = {
             };
           }
         },
-      },
+      }),
       { name: "memory_forget" },
     );
 
     api.registerTool(
-      {
+      (ctx) => ({
         name: "document_search",
         label: "Document Search",
         description:
@@ -889,12 +948,14 @@ const memoryPlugin = {
           ),
         }),
         async execute(_toolCallId, params) {
+          const effectiveCfg = resolveConfig(ctx);
+          const effectiveProvider = getProvider(effectiveCfg);
           const { query, topN } = params as { query: string; topN?: number };
 
           try {
-            const response = await provider.searchDocuments(
+            const response = await effectiveProvider.searchDocuments(
               query,
-              topN ?? cfg.topK,
+              topN ?? effectiveCfg.topK,
             );
 
             if (!response.results || response.results.length === 0) {
@@ -929,12 +990,12 @@ const memoryPlugin = {
             };
           }
         },
-      },
+      }),
       { name: "document_search" },
     );
 
     api.registerTool(
-      {
+      (ctx) => ({
         name: "advanced_web_search",
         label: "Advanced Web Search",
         description:
@@ -986,6 +1047,8 @@ const memoryPlugin = {
           ),
         }),
         async execute(_toolCallId, params) {
+          const effectiveCfg = resolveConfig(ctx);
+          const effectiveProvider = getProvider(effectiveCfg);
           const {
             query,
             domain: rawDomain,
@@ -1005,18 +1068,18 @@ const memoryPlugin = {
               : normalizeWebSearchDomain(rawDomain);
 
           try {
-            const response = await provider.searchWeb(query, {
+            const response = await effectiveProvider.searchWeb(query, {
               domain,
-              max_results: maxResults ?? cfg.topK,
+              max_results: maxResults ?? effectiveCfg.topK,
               start_date: startDate,
               end_date: endDate,
-              include_domains: cfg.webSearchIncludeDomains,
-              exclude_domains: cfg.webSearchExcludeDomains,
+              include_domains: effectiveCfg.webSearchIncludeDomains,
+              exclude_domains: effectiveCfg.webSearchExcludeDomains,
               user_location:
-                cfg.webSearchCountry || cfg.webSearchTimezone
+                effectiveCfg.webSearchCountry || effectiveCfg.webSearchTimezone
                   ? {
-                    country: cfg.webSearchCountry,
-                    timezone: cfg.webSearchTimezone,
+                    country: effectiveCfg.webSearchCountry,
+                    timezone: effectiveCfg.webSearchTimezone,
                   }
                   : undefined,
             });
@@ -1057,7 +1120,7 @@ const memoryPlugin = {
             };
           }
         },
-      },
+      }),
       { optional: true },
     );
 
@@ -1081,7 +1144,7 @@ const memoryPlugin = {
               const limit = parseInt(opts.limit, 10);
               const results = await provider.search(
                 query,
-                buildSearchOptions(undefined, limit),
+                buildSearchOptions(cfg, undefined, limit),
               );
 
               if (!results.length) {
@@ -1133,13 +1196,17 @@ const memoryPlugin = {
       api.on("before_agent_start", async (event, ctx) => {
         if (!event.prompt || event.prompt.length < 5) return;
 
+        // Resolve per-workspace config override
+        const effectiveCfg = resolveConfig(ctx);
+        const effectiveProvider = getProvider(effectiveCfg);
+
         // Track session ID
         const sessionId = (ctx as any)?.sessionKey ?? undefined;
         if (sessionId) currentSessionId = sessionId;
 
         const [memoryResult, docResult] = await Promise.allSettled([
-          provider.search(event.prompt, buildSearchOptions()),
-          provider.searchDocuments(event.prompt, cfg.topK),
+          effectiveProvider.search(event.prompt, buildSearchOptions(effectiveCfg)),
+          effectiveProvider.searchDocuments(event.prompt, effectiveCfg.topK),
         ]);
 
         const contextParts: string[] = [];
@@ -1183,6 +1250,10 @@ const memoryPlugin = {
           return;
         }
 
+        // Resolve per-workspace config override
+        const effectiveCfg = resolveConfig(ctx);
+        const effectiveProvider = getProvider(effectiveCfg);
+
         // Track session ID
         const sessionId = (ctx as any)?.sessionKey ?? undefined;
         if (sessionId) currentSessionId = sessionId;
@@ -1240,8 +1311,8 @@ const memoryPlugin = {
 
           if (formattedMessages.length === 0) return;
 
-          const addOpts = buildAddOptions(undefined, currentSessionId);
-          const result = await provider.add(
+          const addOpts = buildAddOptions(effectiveCfg, undefined, currentSessionId);
+          const result = await effectiveProvider.add(
             formattedMessages,
             addOpts,
           );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memorylake-openclaw",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "type": "module",
   "description": "MemoryLake memory backend for OpenClaw",
   "license": "MIT",

package/skills/agent-memorylake-config/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: agent-memorylake-config
+description: Use when the user asks to configure agent-specific memorylake properties (e.g. projectId) for the current agent. Writes to the agent-specific config file which overrides the global config.
+---
+
+# Agent MemoryLake Config
+
+Configure agent-specific memorylake properties for the current agent. The config file is located at `{workspace}/.memorylake/config.json`, where `{workspace}` is the agent's workspace directory. This config overrides corresponding properties from the global config.
+
+## Step 1 — Confirm projectId
+
+Ask the user for the `projectId` to configure.
+
+If the user has already provided the `projectId` in their message, skip the question and proceed directly.
+
+## Step 2 — Write Config
+
+1. Ensure the `.memorylake/` directory exists inside the agent's workspace directory:
+
+```bash
+cd {workspace}
+mkdir -p .memorylake
+```
+
+2. If `.memorylake/config.json` already exists, read it first and merge the new properties into the existing config. Do NOT overwrite properties the user did not mention.
+
+3. If `.memorylake/config.json` does not exist, create it with the provided properties.
+
+4. Write the config file. Example format:
+
+```json
+{
+  "projectId": "xxx"
+}
+```
+
+## Step 3 — Confirm Result
+
+Read the written `.memorylake/config.json` and confirm to the user that the configuration is complete.
+
+## Common Mistakes
+
+- Do NOT overwrite existing properties that the user did not mention — always merge