memorylake-openclaw 0.0.5 → 0.0.7

package/README.md

@@ -37,7 +37,7 @@ Get an API key from [app.memorylake.ai](https://app.memorylake.ai), then add to
 
 ## Agent tools
 
-The agent gets six tools it can call during conversations:
+The agent gets seven tools it can call during conversations:
 
 | Tool | Description |
 |------|-------------|
@@ -47,6 +47,7 @@ The agent gets six tools it can call during conversations:
 | `memory_get` | Retrieve a memory by ID |
 | `memory_forget` | Delete a memory by ID |
 | `document_search` | Search project documents for relevant paragraphs, tables, and figures |
+| `advanced_web_search` | Optional tool for web search with plugin-level domain and locale constraints |
 
 ## CLI
 
@@ -70,6 +71,12 @@ openclaw memorylake stats
 | `topK` | `number` | `5` | Max memories per recall |
 | `searchThreshold` | `number` | `0.3` | Min similarity (0–1) |
 | `rerank` | `boolean` | `true` | Rerank search results |
+| `webSearchIncludeDomains` | `string[]` | — | Optional allowlist for `advanced_web_search` results |
+| `webSearchExcludeDomains` | `string[]` | — | Optional denylist for `advanced_web_search` results |
+| `webSearchCountry` | `string` | — | Optional ISO country code for localizing `advanced_web_search` |
+| `webSearchTimezone` | `string` | — | Optional IANA timezone for localizing `advanced_web_search` |
+
+`advanced_web_search` is registered as an optional OpenClaw tool, so agents must explicitly allow it before they can call it.
 
 ## License
 

package/docs/openclaw.mdx

@@ -13,7 +13,7 @@ Add long-term memory to [OpenClaw](https://github.com/openclaw/openclaw) agents
 The plugin provides:
 1. **Auto-Recall** — Before the agent responds, memories and relevant document excerpts matching the current message are injected into context
 2. **Auto-Capture** — After the agent responds, the exchange is sent to MemoryLake which decides what's worth keeping
-3. **Agent Tools** — Six tools for memory and document operations during conversations
+3. **Agent Tools** — Seven tools for memory, document, and optional web search operations during conversations
 
 Both auto-recall and auto-capture run silently with no manual configuration required.
 
@@ -42,7 +42,7 @@ Add to your `openclaw.json`:
 
 ## Agent Tools
 
-The agent gets six tools it can call during conversations:
+The agent gets seven tools it can call during conversations:
 
 | Tool | Description |
 |------|-------------|
@@ -52,6 +52,7 @@ The agent gets six tools it can call during conversations:
 | `memory_get` | Retrieve a memory by ID |
 | `memory_forget` | Delete a memory by ID |
 | `document_search` | Search project documents for relevant paragraphs, tables, and figures |
+| `advanced_web_search` | Optional web search tool backed by the unified search API with plugin-level domain and locale constraints |
 
 ## CLI Commands
 
@@ -75,13 +76,19 @@ openclaw memorylake stats
 | `topK` | `number` | `5` | Max memories per recall |
 | `searchThreshold` | `number` | `0.3` | Min similarity (0–1) |
 | `rerank` | `boolean` | `true` | Rerank search results for better relevance |
+| `webSearchIncludeDomains` | `string[]` | — | Optional allowlist for `advanced_web_search` results |
+| `webSearchExcludeDomains` | `string[]` | — | Optional denylist for `advanced_web_search` results |
+| `webSearchCountry` | `string` | — | Optional ISO country code for localizing `advanced_web_search` |
+| `webSearchTimezone` | `string` | — | Optional IANA timezone for localizing `advanced_web_search` |
+
+<Note>`advanced_web_search` is registered as an optional OpenClaw tool, so it must be explicitly allowed before an agent can call it.</Note>
 
 ## Key Features
 
 1. **Zero Configuration** — Auto-recall and auto-capture work out of the box with no prompting required
 2. **Async Processing** — Memory extraction runs asynchronously via MemoryLake's API
 3. **Session Tracking** — Conversations are tagged with `chat_session_id` for traceability
-4. **Rich Tool Suite** — Six agent tools for memory and document operations when needed
+4. **Rich Tool Suite** — Seven agent tools for memory, document, and optional web search operations when needed
 
 ## Conclusion
 

package/index.ts

@@ -4,12 +4,14 @@
  * Long-term memory via MemoryLake platform.
  *
  * Features:
- * - 6 tools: memory_search, memory_list, memory_store, memory_get, memory_forget, document_search
+ * - 7 tools: memory_search, memory_list, memory_store, memory_get, memory_forget, document_search, advanced_web_search
  * - Auto-recall: injects relevant memories and document excerpts before each agent turn
  * - Auto-capture: stores key facts scoped to the current session after each agent turn
  * - 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";
@@ -29,6 +31,10 @@ type MemoryLakeConfig = {
   searchThreshold: number;
   topK: number;
   rerank: boolean;
+  webSearchIncludeDomains?: string[];
+  webSearchExcludeDomains?: string[];
+  webSearchCountry?: string;
+  webSearchTimezone?: string;
 };
 
 // V2 API option types
@@ -99,6 +105,68 @@ interface DocumentSearchResponse {
   results: DocumentSearchResult[];
 }
 
+/**
+ * Allowed values for web search domain (aligned with zootopia unified_search Domain).
+ * Declared as enum in schema; at runtime accept string and fall back to "auto" if invalid.
+ */
+const WebSearchDomainValues = [
+  "web",
+  "academic",
+  "news",
+  "people",
+  "company",
+  "financial",
+  "markets",
+  "code",
+  "legal",
+  "government",
+  "poi",
+  "auto",
+] as const;
+type WebSearchDomain = (typeof WebSearchDomainValues)[number];
+
+const WEB_SEARCH_DOMAIN_SET = new Set<string>(WebSearchDomainValues);
+
+/** Normalize domain: accept string at runtime; if not a valid enum value, return "auto". */
+function normalizeWebSearchDomain(value: unknown): WebSearchDomain {
+  if (value == null) return "auto";
+  const s = typeof value === "string" ? value.toLowerCase().trim() : "";
+  return (WEB_SEARCH_DOMAIN_SET.has(s) ? s : "auto") as WebSearchDomain;
+}
+
+interface WebSearchUserLocation {
+  country?: string;
+  timezone?: string;
+}
+
+interface WebSearchOptions {
+  /** Declared as enum in schema; at runtime accept string, normalized with fallback to "auto". */
+  domain?: WebSearchDomain | string;
+  max_results?: number;
+  start_date?: string;
+  end_date?: string;
+  include_domains?: string[];
+  exclude_domains?: string[];
+  user_location?: WebSearchUserLocation;
+}
+
+interface WebSearchResult {
+  url?: string;
+  title?: string;
+  summary?: string;
+  content?: string;
+  source?: string;
+  published_date?: string;
+  author?: string;
+  score?: number;
+  highlights?: string[];
+}
+
+interface WebSearchResponse {
+  results: WebSearchResult[];
+  total_results: number;
+}
+
 // ============================================================================
 // Unified Provider Interface
 // ============================================================================
@@ -113,6 +181,7 @@ interface MemoryLakeProvider {
   getAll(options: ListOptions): Promise<MemoryItem[]>;
   delete(memoryId: string): Promise<void>;
   searchDocuments(query: string, topN: number): Promise<DocumentSearchResponse>;
+  searchWeb(query: string, options: WebSearchOptions): Promise<WebSearchResponse>;
 }
 
 // ============================================================================
@@ -130,10 +199,12 @@ class PlatformProvider implements MemoryLakeProvider {
   private readonly http: ReturnType<typeof got.extend>;
   private readonly basePath: string;
   private readonly docSearchPath: string;
+  private readonly webSearchPath: string;
 
   constructor(host: string, apiKey: string, projectId: string) {
     this.basePath = `openapi/memorylake/api/v2/projects/${projectId}/memories`;
     this.docSearchPath = `openapi/memorylake/api/v1/projects/${projectId}/documents/search`;
+    this.webSearchPath = "openapi/memorylake/api/v1/search"; 
     this.http = got.extend({
       prefixUrl: host,
       headers: {
@@ -220,6 +291,25 @@ class PlatformProvider implements MemoryLakeProvider {
       results: Array.isArray(data?.results) ? data.results : [],
     };
   }
+
+  async searchWeb(query: string, options: WebSearchOptions): Promise<WebSearchResponse> {
+    const domain = options.domain != null ? normalizeWebSearchDomain(options.domain) : "web";
+    const body: Record<string, unknown> = {
+      query,
+      domain,
+    };
+    if (options.max_results != null) body.max_results = options.max_results;
+    if (options.start_date) body.start_date = options.start_date;
+    if (options.end_date) body.end_date = options.end_date;
+    if (options.include_domains?.length) body.include_domains = options.include_domains;
+    if (options.exclude_domains?.length) body.exclude_domains = options.exclude_domains;
+    if (options.user_location) body.user_location = options.user_location;
+
+    const resp = await this.http
+      .post(this.webSearchPath, { json: body })
+      .json<WebSearchResponse>();
+    return normalizeWebSearchResponse(resp);
+  }
 }
 
 // ============================================================================
@@ -254,6 +344,13 @@ function normalizeAddResult(raw: any): AddResult {
   };
 }
 
+function normalizeWebSearchResponse(raw: any): WebSearchResponse {
+  return {
+    results: Array.isArray(raw?.results) ? raw.results : [],
+    total_results: typeof raw?.total_results === "number" ? raw.total_results : 0,
+  };
+}
+
 // ============================================================================
 // Document Context Builder
 // ============================================================================
@@ -302,6 +399,19 @@ function buildDocumentContext(
   return parts.join("\n\n");
 }
 
+function buildWebSearchContext(results: WebSearchResult[]): string {
+  return results
+    .map((result, index) => {
+      const parts = [`${index + 1}. ${result.title ?? result.url ?? "Untitled result"}`];
+      if (result.url) parts.push(`URL: ${result.url}`);
+      if (result.summary) parts.push(`Summary: ${result.summary}`);
+      if (result.source) parts.push(`Source: ${result.source}`);
+      if (result.published_date) parts.push(`Published: ${result.published_date}`);
+      return parts.join("\n");
+    })
+    .join("\n\n");
+}
+
 // ============================================================================
 // Config Parser
 // ============================================================================
@@ -320,6 +430,10 @@ const ALLOWED_KEYS = [
   "searchThreshold",
   "topK",
   "rerank",
+  "webSearchIncludeDomains",
+  "webSearchExcludeDomains",
+  "webSearchCountry",
+  "webSearchTimezone",
 ];
 
 function assertAllowedKeys(
@@ -332,6 +446,28 @@ function assertAllowedKeys(
   throw new Error(`${label} has unknown keys: ${unknown.join(", ")}`);
 }
 
+function parseOptionalStringArray(
+  value: unknown,
+  label: string,
+): string[] | undefined {
+  if (value == null) return undefined;
+  if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) {
+    throw new Error(`${label} must be an array of strings`);
+  }
+  return value;
+}
+
+function parseOptionalString(
+  value: unknown,
+  label: string,
+): string | undefined {
+  if (value == null) return undefined;
+  if (typeof value !== "string") {
+    throw new Error(`${label} must be a string`);
+  }
+  return value;
+}
+
 const memoryLakeConfigSchema = {
   parse(value: unknown): MemoryLakeConfig {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -361,6 +497,22 @@ const memoryLakeConfigSchema = {
         typeof cfg.searchThreshold === "number" ? cfg.searchThreshold : 0.3,
       topK: typeof cfg.topK === "number" ? cfg.topK : 5,
       rerank: cfg.rerank !== false,
+      webSearchIncludeDomains: parseOptionalStringArray(
+        cfg.webSearchIncludeDomains,
+        "webSearchIncludeDomains",
+      ),
+      webSearchExcludeDomains: parseOptionalStringArray(
+        cfg.webSearchExcludeDomains,
+        "webSearchExcludeDomains",
+      ),
+      webSearchCountry: parseOptionalString(
+        cfg.webSearchCountry,
+        "webSearchCountry",
+      ),
+      webSearchTimezone: parseOptionalString(
+        cfg.webSearchTimezone,
+        "webSearchTimezone",
+      ),
     };
   },
 };
@@ -380,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;
 
@@ -388,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" },
       };
@@ -400,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,
       };
     }
 
@@ -416,7 +615,7 @@ const memoryPlugin = {
     // ========================================================================
 
     api.registerTool(
-      {
+      (ctx) => ({
         name: "memory_search",
         label: "Memory Search",
         description:
@@ -446,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;
@@ -454,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) {
@@ -502,12 +703,12 @@ const memoryPlugin = {
             };
           }
         },
-      },
+      }),
       { name: "memory_search" },
     );
 
     api.registerTool(
-      {
+      (ctx) => ({
         name: "memory_store",
         label: "Memory Store",
         description:
@@ -526,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;
@@ -533,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;
@@ -566,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.",
@@ -579,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: [
@@ -605,12 +810,12 @@ const memoryPlugin = {
             };
           }
         },
-      },
+      }),
       { name: "memory_get" },
     );
 
     api.registerTool(
-      {
+      (ctx) => ({
         name: "memory_list",
         label: "Memory List",
         description:
@@ -634,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 {
@@ -683,12 +890,12 @@ const memoryPlugin = {
             };
           }
         },
-      },
+      }),
       { name: "memory_list" },
     );
 
     api.registerTool(
-      {
+      (ctx) => ({
         name: "memory_forget",
         label: "Memory Forget",
         description:
@@ -697,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.` },
@@ -719,12 +928,12 @@ const memoryPlugin = {
             };
           }
         },
-      },
+      }),
       { name: "memory_forget" },
     );
 
     api.registerTool(
-      {
+      (ctx) => ({
         name: "document_search",
         label: "Document Search",
         description:
@@ -739,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) {
@@ -779,10 +990,140 @@ const memoryPlugin = {
             };
           }
         },
-      },
+      }),
       { name: "document_search" },
     );
 
+    api.registerTool(
+      (ctx) => ({
+        name: "advanced_web_search",
+        label: "Advanced Web Search",
+        description:
+          "Search the web using the unified search API with plugin-level domain and location constraints. Use this for recent information, public web pages, or web research that should respect configured allowed domains, blocked domains, and user locale.",
+        parameters: Type.Object({
+          query: Type.String({
+            description:
+              "The web search query to send to the unified search endpoint.",
+          }),
+          domain: Type.Optional(
+            Type.Union(
+              [
+                Type.Literal("web"),
+                Type.Literal("academic"),
+                Type.Literal("news"),
+                Type.Literal("people"),
+                Type.Literal("company"),
+                Type.Literal("financial"),
+                Type.Literal("markets"),
+                Type.Literal("code"),
+                Type.Literal("legal"),
+                Type.Literal("government"),
+                Type.Literal("poi"),
+                Type.Literal("auto"),
+              ],
+              {
+                description:
+                  "Search domain. Default: web. Invalid or unknown values are treated as auto.",
+              },
+            ),
+          ),
+          maxResults: Type.Optional(
+            Type.Number({
+              description: `Maximum number of web results to return (default: ${cfg.topK}).`,
+              minimum: 1,
+            }),
+          ),
+          startDate: Type.Optional(
+            Type.String({
+              description:
+                "Only include results published on or after this date (YYYY-MM-DD).",
+            }),
+          ),
+          endDate: Type.Optional(
+            Type.String({
+              description:
+                "Only include results published on or before this date (YYYY-MM-DD).",
+            }),
+          ),
+        }),
+        async execute(_toolCallId, params) {
+          const effectiveCfg = resolveConfig(ctx);
+          const effectiveProvider = getProvider(effectiveCfg);
+          const {
+            query,
+            domain: rawDomain,
+            maxResults,
+            startDate,
+            endDate,
+          } = params as {
+            query: string;
+            domain?: string;
+            maxResults?: number;
+            startDate?: string;
+            endDate?: string;
+          };
+          const domain: WebSearchDomain =
+            rawDomain === undefined || rawDomain === null
+              ? "web"
+              : normalizeWebSearchDomain(rawDomain);
+
+          try {
+            const response = await effectiveProvider.searchWeb(query, {
+              domain,
+              max_results: maxResults ?? effectiveCfg.topK,
+              start_date: startDate,
+              end_date: endDate,
+              include_domains: effectiveCfg.webSearchIncludeDomains,
+              exclude_domains: effectiveCfg.webSearchExcludeDomains,
+              user_location:
+                effectiveCfg.webSearchCountry || effectiveCfg.webSearchTimezone
+                  ? {
+                    country: effectiveCfg.webSearchCountry,
+                    timezone: effectiveCfg.webSearchTimezone,
+                  }
+                  : undefined,
+            });
+
+            if (!response.results || response.results.length === 0) {
+              return {
+                content: [
+                  { type: "text", text: "No relevant web results found." },
+                ],
+                details: { count: 0, total_results: response.total_results },
+              };
+            }
+
+            const context = buildWebSearchContext(response.results);
+
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Found ${response.results.length} web results:\n\n${context}`,
+                },
+              ],
+              details: {
+                count: response.results.length,
+                total_results: response.total_results,
+                results: response.results,
+              },
+            };
+          } catch (err) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Web search failed: ${String(err)}`,
+                },
+              ],
+              details: { error: String(err) },
+            };
+          }
+        },
+      }),
+      { optional: true },
+    );
+
     // ========================================================================
     // CLI Commands
     // ========================================================================
@@ -803,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) {
@@ -855,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[] = [];
@@ -905,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;
@@ -962,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/openclaw.plugin.json

@@ -35,6 +35,26 @@
     "rerank": {
       "label": "Rerank",
       "help": "Rerank search results"
+    },
+    "webSearchIncludeDomains": {
+      "label": "Web Search Allowed Domains",
+      "placeholder": "[\"example.com\", \"docs.example.com\"]",
+      "help": "Optional allowlist for advanced_web_search results."
+    },
+    "webSearchExcludeDomains": {
+      "label": "Web Search Blocked Domains",
+      "placeholder": "[\"example.com\"]",
+      "help": "Optional denylist for advanced_web_search results."
+    },
+    "webSearchCountry": {
+      "label": "Web Search Country",
+      "placeholder": "US",
+      "help": "Optional ISO country code used to localize advanced_web_search results."
+    },
+    "webSearchTimezone": {
+      "label": "Web Search Timezone",
+      "placeholder": "America/Los_Angeles",
+      "help": "Optional IANA timezone used to localize advanced_web_search results."
     }
   },
   "configSchema": {
@@ -64,6 +84,24 @@
       },
       "rerank": {
         "type": "boolean"
+      },
+      "webSearchIncludeDomains": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        }
+      },
+      "webSearchExcludeDomains": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        }
+      },
+      "webSearchCountry": {
+        "type": "string"
+      },
+      "webSearchTimezone": {
+        "type": "string"
       }
     },
     "required": []

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memorylake-openclaw",
-  "version": "0.0.5",
+  "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